How to use Gradescope: A Student Guide

Gradescope is a renowned tool that helps instructors seamlessly grade and administer programming assignments. It provides a clear picture of the progress of students and saves time. It is not only instructors that should know how to use Gradescope. Students too need to know how to use Gradescope to:

Submit their homework for grading
Viewing scores and feedback
Requesting for a re-grade within the prescribed guidelines

Gradescope is a unique tool that supports both variable-length and fixed-template programming assignments. You can submit multiple assignments of any file type. Gradescope also allows students to submit their programming assignments via BitBucket Integration and GitHub. Your professor can then auto-grade or manually grade your code. Manual grading supports in-line comments and grading with a rubric.

Submitting your programming assignment in Gradescope

It is recommended that you scan any handwritten work you upload to Gradescope. The scanned work should be uploaded as a PDF. Gradescope may not have a file size limit, but it usually rejects large files because they take time to process. Also, it would be best to use scanning apps that support iOS and Android devices. Gradescope gives you a chance to submit your assignment as a PDF or image. The steps to submit an assignment may vary depending on the type of assignment. In addition to submitting online and handwritten assignments, Gradescope allows you to submit code. Programming students who want to submit code have the following three options:

Dragging and dropping their code files into Gradescope
Submitting a Bitbucket repository
Submitting a Github repository

Here are tips for uploading your assignment:

Images on the phone and handwritten work: The first step is to ensure that you have a Gradescope mobile app. You can download it from their official website. After ensuring that the app is working and logging in, you can submit your assignment.
Images and PDF on your computer: You should choose whether you upload a PDF or images. Find the images or PDF you want to submit on your computer and click on open. Click on the submit button once they have been uploaded.

Troubleshooting Gradescope

Most students who use Safari as their browser have complained about their assignments not loading. If you are using Safari to access Gradescope, you should adjust the security settings. Safari is known to block third-party apps and cookies. These settings may stop certain tools from working in Gradescope. If you are using Safari as your browser and you notice that your assignment is stuck on the loading page, please follow these simple steps:

Go to the Safari menu.
Move to preferences and then select Privacy
Uncheck “prevent cross-site tracking

You can also avoid this hurdle by using another browser like chrome.

The best thing about Gradescope is that you can modify your answers and re-submit your programming assignment as often as possible. However, your resubmissions have to be within the allotted timeframe. You will not be able to submit your assignment when the submission time ends. If you were working on a timed programming exam and time ran out before you could submit, Gradescope will automatically save your work and submit what has been done. Also, if you mistakenly closed down your browser or lost your internet connection, you can always navigate back to your assignment or exam. All the answers that you enter are auto-saved. However, the timer never stops. There is an auto-save indicator at the top of the left screen. You can always check it.

Viewing comments and feedback from your professor

You can quickly access the feedback and comments from your professor through the assignment link. All published comments and feedback will appear there. For timed assignments, click on view submission. On the other hand, you do not need to click on view submission if the assignment was not timed. The feedback will appear straight away. You can view the marked paper as well as your answers. The rubric always appears on the right-hand side, with your score on top. You can click on specific questions and expand if you want to see detailed comments and scores.

Submitting a re-grade request

Different instructors have different guidelines for when to submit a re-grade request and what should be included. You should check with your instructor before submitting a request. Re-grade requests are for programming assignments you feel were graded incorrectly. View your submission and check if the re-grade button has been enabled to check if re-grade requests are allowed. Follow these steps to submit your request:

Click on the questions you wish to submit a re-grade request for. You should be able to see the rubric and the items that were applied to the questions.
In the action bar, click on the request re-grade button
Explain why you feel the question should be regarded on the textbox that appears
Submit

Gradescope allows re-grade requests per question. It means that you must submit a request for each if you have multiple questions that you feel were incorrectly graded. A notification email will be sent to your instructor once your request has been sent. Your instructor can choose to re-grade, send you a response or close your case. You will receive a notification email once your request has been resolved. When you view the submission, you can view all the completed and pending re-grade requests.

Bottomline

Gradescope ensures that instructors and students collaborate better on grading. It allows you to participate in course activities assigned by your professor. If you have issues with Gradescope, link up with your instructor. They may be able to provide you with the real-time assistance that you need. No matter how complicated your programming homework is, your professor expects you to meet to submit your solution via Gradescope on time. One of the easiest ways to beat your strict java assignment deadline is to get assistance from an experienced java professional. For more information on how to use Gradescope, you can explore the documentation for students available on their website.

The Squabble Game

Squabble is one of the most interesting word games. Several people have fallen in love with this game because of the special features that make it exciting and nerve-racking at the same time. The rules are simple. Each player gets six chances to guess a five-lettered word that has been selected randomly. A player can only enter six words. In other words, you can enter five burner words that give you hints about the letters and their placements. The letters you guess are labeled as correct, used, or unused while considering a mystery word. For example, suppose the mystery word was "ADULT," but a player's guess was 'AGENT" the labeling will be as follows: A-correct, G-unused, E-unused, N-unused, and T-correct. This information can guide the player in the next guess and narrows down what the mystery word could be. Too much thought was put into creating this game of rules. Our tool aims to be less constrained and expand the possibilities. For instance, we will make the guesses and the word length arbitrary. We are also lifting textual limitations in our tools to support different letters other than those in the alphabet. To be more specific, our tools will allow for more variants for a Squabble-Esque game while still retaining the idea of labeling letters as per the mystery word.

ExtendedLetter.Java


/**
 * This class represents an Extended Letter.
 */
public class ExtendedLetter extends Letter {
    private String content;
    private int family;
    private boolean related;
    private static final int SINGLETON = -1;

    /**
     * Creates an ExtendedLetter object given the string.
     * @param s String
     */
    public ExtendedLetter(String s) {
        super(s.charAt(0));
        content = s;
        related = false;
        family = SINGLETON;
    }
    /**
     * Creates an ExtendedLetter object, given String and family.
     * @param s String
     * @param fam int
     */
    public ExtendedLetter(String s, int fam) {
        super(s.charAt(0));
        content = s;
        family = fam;
        related = false;
    }
    /**
     * Compares two ExtendedLetter objects
     */
    public boolean equals(Object other) {
        if (!(other instanceof ExtendedLetter)) {
            return false;
        }
        ExtendedLetter obj = (ExtendedLetter)other;
        if (getFamily() == obj.getFamily()) {
            this.related = true;
        }
        return obj.getContent().equals(this.content);
    }

    /**
     * Getter for family.
     * @return Integer
     */
    public int getFamily() {
        return this.family;
    }
    /**
     * Getter for content.
     * @return String
     */
    public String getContent() {
        return this.content;
    }
    /**
     * Overrided toString method.
     */
    @Override
    public String toString() {
        if(this.isUnused() && this.related) {
            return "." + this.content + ".";
        }
        else {
            return this.decorator() + this.content + this.decorator();
        }
    }
    /**
     * Returns an array of Letter object given an string and family arr.
     * @param content String array
     * @param codes Integer array
     * @return Letter array
     */
    public static Letter[] fromStrings(String[] content, int[]codes) {
        // Create an array of letter with the same size of content
        Letter[] letters = new Letter[content.length];
        if (codes == null) {
            for (int i = 0; i < content.length; i++) {
                letters[i] = new ExtendedLetter(content[i]);
            }
        } else {
            for (int i = 0; i < content.length; i++) {
                letters[i] = new ExtendedLetter(content[i], codes[i]);
            }
        }
        return letters;
    }

}

Letter.Java


/**
 * Creates a Letter object.
 */
public class Letter {
    private char letter;
    private int label;

    private static final int UNSET = 0;
    private static final int UNUSED = 1;
    private static final int USED = 2;
    private static final int CORRECT = 3;

    public Letter(char c) {
        letter = c;
        label = UNSET;
    }

    public boolean equals(Object otherObject) {
        if(!(otherObject instanceof Letter)) {
            return false;
        }

        Letter obj = (Letter)otherObject;
        return this.letter == obj.getLetter();
    }

    public String decorator() {
        String ret = "";
        switch(this.label) {
            case UNSET:
                ret = " ";
                break;
            case UNUSED:
                ret = "-";
                break;
            case USED:
                ret = "+";
                break;
            case CORRECT:
                ret = "!";
                break;
        }

        return ret;
    }

    @Override
    public String toString() {
        return decorator() + ("" + getLetter()).toUpperCase() + decorator();
    }

    public void setUnused() {
        label = UNUSED;
    }

    public void setUsed() {
        label = USED;
    }

    public void setCorrect() {
        label = CORRECT;
    }

    public boolean isUnused() {
        return label == UNUSED;
    }

    public static Letter[] fromString(String s) {
        Letter[] letters = new Letter[s.length()];
        for(int i = 0; i < s.length(); i++) {
            letters[i] = new Letter(s.charAt(i));
        }

        return letters;
    }

    // getters
    public char getLetter() {
        return letter;
    }
}

LinearNode.Java


/**
 * LinearNode represents a node in a linked list.
 *
 * @author Dr. Lewis
 * @author Dr. Chase
 * @version 1.0, 08/13/08
 */

public class LinearNode{
    private LinearNode next;
    private E element;
    
    /**
     * Creates an empty node.
     */
    public LinearNode()
    {
        next = null;
        element = null;
    }
    
    /**
     * Creates a node storing the specified element.
     *
     * @param elem  the element to be stored within the new node
     */
    public LinearNode (E elem)
    {
        next = null;
        element = elem;
    }
    
    /**
     * Returns the node that follows this one.
     *
     * @return  the node that follows the current one
     */
    public LinearNode getNext()
    {
        return next;
    }
    
    /**
     * Sets the node that follows this one.
     *
     * @param node  the node to be set to follow the current one
     */
    public void setNext (LinearNode node)
    {
        next = node;
    }
    
    /**
     * Returns the element stored in this node.
     *
     * @return  the element stored in this node
     */
    public E getElement()
    {
        return element;
    }
    
    /**
     * Sets the element stored in this node.
     *
     * @param elem  the element to be stored in this node
     */
    public void setElement (E elem)
    {
        element = elem;
    }
}

TestWordLL


public class TestWordLL {

	public static int passed = 0;
	public static int tested = 0;

	public static void main(String[] args) {
		//--------------------
		Letter letter1 = new Letter('J');
		Letter letter2 = new Letter('V');
		Letter letter3 = new Letter('J');

		// ********** Letter equals
		test(1,"Letter equals", !letter1.equals(letter2) && letter1.equals(letter3));
		letter1.setCorrect();
		letter2.setUsed();
		letter3.setUnused();

		// ********** Letter set methods
		test(2,"Letter set methods", (letter1.toString()+letter2.toString()+letter3.toString()).equals("!J!+V+-J-"));
		Letter[] array = Letter.fromString("JAVA");

		// ********** Letter fromString
		test(3,"Letter fromString", array[1].equals(array[3]) && array[0].equals(letter1));
		Word word1 = new Word(Letter.fromString("OBJECT"));
		Word word2 = new Word(Letter.fromString("CLASS"));
		word2.labelWord(word1);
		Word word3 = new Word(Letter.fromString("CODE"));
		word3.labelWord(word1);

		// ********** Word toString + Constructor
		test(4,"Word toString + Constructor", word1.toString().equals("Word:  O   B   J   E   C   T  "));

		// ********** Word label
		test(5,"Word label", word2.toString().equals("Word: +C+ -L- -A- -S- -S- "));

		// ********** Word label
		test(6,"Word label", word3.toString().equals("Word: +C+ +O+ -D- !E! "));

		// ********** Word label
		test(7,"Word label", (word1.labelWord(word1)+word1.toString()).equals("trueWord: !O! !B! !J! !E! !C! !T! "));

		// ********** Word label
		test(8,"Word label", (word1.labelWord(word3)+word1.toString()).equals("falseWord: +O+ -B- -J- !E! +C+ -T- "));
		WordLL wll = new WordLL(new Word(Letter.fromString("OBJECT")));
		String[] arr = {"JOB","TESTING","OBJECTS"};
		for(int i=0;i

Word.Java


/**
 * Create a Word object.
 */
public class Word {
    private LinearNode firstLetter;    /**
     * Constructor that receives a Letter array.
     * @param letters Letter array
     */
    public Word(Letter[] letters) {
        firstLetter = new LinearNode(letters[0]);
        LinearNode current = firstLetter;
        for (int i = 1; i < letters.length; i++) {
            current.setNext(new LinearNode(letters[i]));
            current = current.getNext();
        }
    }
    /**
     * Overrided toString method.
     */
    @Override
    public String toString() {
        String ret = "Word: ";
        LinearNode current = firstLetter;
        while (current != null) {
            ret += current.getElement().toString() + " ";
            current = current.getNext();
        }
        return ret;
    }
    /**
     * Compares letter objects from words to label them.
     * @param mystery Word object
     * @return boolean
     */
    public boolean labelWord(Word mystery) {
        
        // Loop over the letters in this word
        LinearNode current = firstLetter;
        int i = 0;
        int j;
        boolean used;
        int correct = 0;
        while (current != null) {
            used = false;
            // Set the label of the current letter to UNUSED
            //current.getElement().setUnused();
            // Loop over the letters in the mystery word
            LinearNode mCurrent = mystery.getFirstLetter();
            j = 0;
            while (mCurrent != null) {
                // if get words are equal but in different index, set label to USED
                if (current.getElement().equals(mCurrent.getElement())) {
                    if (i != j) {
                        // Different index
                        current.getElement().setUsed();
                    } else {
                        //If the index are the same, the letter is correct
                        current.getElement().setCorrect();
                        correct++;
                    }
                    used = true;
                }
                mCurrent = mCurrent.getNext();
                j++;
            }

            // If the variable 'used' is false, then the letter is unused
            if (!used) {
                current.getElement().setUnused();
            }
            current = current.getNext();
            i++;
        }
        // If the counter 'correct' is equal to the number of elements in the LL, return true
        return correct == i;
    }
    /**
     * Getter method for firstLetter.
     * @return LinearNode of Letter object
     */
    public LinearNode getFirstLetter() {        return firstLetter;
    }

}

WordLL.Java


/**
 * Creates a Word Linked List object.
 */
public class WordLL {
    private Word mysteryWord;
    private LinearNode history;    /**
     * Initializes a WordLL object.
     * @param mystery Word object
     */
    public WordLL(Word mystery) {
        mysteryWord = mystery;
        history = new LinearNode();
    }
    /**
     * Compares to check if the words matches.
     * @param guess Word object
     * @return boolean
     */
    public boolean tryWord(Word guess) {
        boolean result = guess.labelWord(mysteryWord);
        // Add to front
        LinearNode newNode = new LinearNode(guess);
        if (history.getElement() == null) {
            // history is empty
            history = newNode;
        } else {
            newNode.setNext(history);
            history = newNode;
        }
        return result;
    }
    /**
     * Overrided toString method.
     */
    @Override
    public String toString() {
        String ret = "";
        LinearNode current = history;
        while (current != null) {
            ret += current.getElement().toString() + "\n";
            current = current.getNext();
        }

        return ret;
    }
}

WordLLExample. Java


import java.util.Scanner;
import java.io.File;
import java.io.FileNotFoundException;

public class WordLLExamples {
	private static Scanner scan;
	private static final int NUMBER_OF_WORDS = 2992; // Number of possible mystery words
	private static String[] mysteryWord = new String[NUMBER_OF_WORDS];

	private static String[] rank = { "9", "10", "J", "Q", "K", "A" };
	private static String[] suit = { "C", "D", "H", "S" };
	/** 
	 * a utility function to create card sets
	 * @return a random Word representing an ascending set of 4 Euchre Cards.
	 *         The idea of ascending comes from both the rank (ordered: 9,10,jack,queen,king,ace) 
	 *         and the suit (ordered: clubs, diamonds, hearts, spades) 
	 *         in particular the ordering will be: 9C,10C,JC,QC,KC,AC,9D,...,AC,9H,...,AH,9S,...,AS
	 *         As well, cards of the same rank will be regarded as being related: so for instance,
	 *         9C, 9D, 9H, and 9S are related
	 */
	public static Word ascendingEuchreCards() {
		// create a combination of (24 choose 4)
		int[] choice = new int[4];
		for (int i = 0; i < choice.length; i++) {
			boolean taken = false;
			do {
				taken = false;
				choice[i] = pick(24);
				for (int j = 0; j < i; j++)
					if (choice[j] == choice[i])
						taken = true;
			} while (taken);
		}
		// sort into ascending order
		for (int i = 0; i < choice.length; i++) {
			int min = i;
			for (int j = i; j < choice.length; j++) {
				if (choice[j] < choice[min])
					min = j;
			}
			int temp = choice[i];
			choice[i] = choice[min];
			choice[min] = temp;
		}

		// create String representations for of the 24 cards and corresponding families
		String[] card = new String[4];
        int[] family = new int[4];
		for (int i = 0; i < choice.length; i++) {
			card[i] = rank[choice[i] % 6] + suit[(int) Math.floor(choice[i] / 6)];
			family[i] = choice[i] % 6; //only the rank is important for the relatedness 
		}
		return new Word(ExtendedLetter.fromStrings(card, family));
	}

	/* Read input file 'words' that contains about 3000 mystery words */
	public static void readMysteryWords(String filename) {
		try {
			File myObj = new File(filename);
			Scanner myReader = new Scanner(myObj);
			int i = 0;
			while (myReader.hasNextLine()) {
				mysteryWord[i++] = myReader.nextLine();
				// System.out.println(mysteryWord[i-1]);
			}
			myReader.close();
		} catch (FileNotFoundException e) {
			System.out.println("An error occurred opening file \'words\'.");
			e.printStackTrace();
		}
	}

	public static int pick(int n) { // return an random choice 0-(n-1)
		return (int) Math.floor(Math.random() * n);
	}

	public static void main(String[] args) {
		scan = new Scanner(System.in, "UTF-8");

		//readMysteryWords("words");
		//playEnglish();
		playCards();
		System.out.println("end of testing.");
	}

	/* Play WordLL with words of varying lengths */
	public static void playEnglish() {
		String randomWord = mysteryWord[pick(mysteryWord.length)].toUpperCase();
		Word mystery = new Word(Letter.fromString(randomWord));
		String message = "Enter a word of length " + randomWord.length() + " (XX to stop):";

		WordLL wll = new WordLL(mystery);

		System.out.print(message);
		String wordStr = scan.next().toUpperCase();
		while (!wordStr.equals("XX")) {
			Word word = new Word(Letter.fromString(wordStr));
			if (wll.tryWord(word)) {
				System.out.println("Success!");
				wordStr = "XX";
			} else {
				System.out.println(wll);
				System.out.print(message);
				wordStr = scan.next().toUpperCase();
			}
		}
	}

	/* Play WordLL with Euchre Cards rather than using the implicit patterns of language this game relies on
	 * an ordering of the cards and the ranks of a card to give you information about the mystery "Word" 
	 * which is just a sequence of 4 cards.  */
	public static void playCards() {
		Word mystery = ascendingEuchreCards();
		System.out.println("To Enter cards use this format: AC,KC,9H,1S or R (for a random guess)");
		String message = "Enter 4 Cards (XX to stop):";

		WordLL wll = new WordLL(mystery);
		// --------------------
		Word word = null;

		System.out.print(message);
		String wordStr = scan.next().toUpperCase();
		while (!wordStr.equals("XX")) {
			try {
				if (wordStr.charAt(0) == 'R')  
					// this option saves on typing and lets the player start with some information
					word = ascendingEuchreCards();
				else {
					// construct a card Word from the textual input 
					String[] card = new String[4];
					int[] rank = new int[4];
					for (int i = 0; i < card.length; i++) {
						card[i] = wordStr.substring(i * 3, i * 3 + 2);
						if (card[i].charAt(0)=='1') card[i]="10"+card[i].charAt(1);  //ugly
						//System.out.print(card[i]);
						rank[i] = "91JQKA".indexOf(card[i].charAt(0));  
					}
					word = new Word(ExtendedLetter.fromStrings(card, rank));
				}
				if (wll.tryWord(word)) {
					System.out.println("Success!");
					wordStr = "XX";
				} else {
					System.out.println(wll);  // shows the outcome of the guess through the WordLL history
					System.out.print(message);
					wordStr = scan.next().toUpperCase();
				}
			} catch (Exception e) {
				System.out.println(e);
				wordStr = "XX";
			}
		}
	}
}