Details
Table of Contents

- Project Overview & Goals -

​​

- ​My Work -

​​

- Methodology & Approach -

​​

- Key Activities & Execution -

​​

- Deliverables & Outcomes -

​​

- Tools & Technologies Used -

Project Overview & Goals

​Project Overview

This project originated within a systems programming course as the final assignment. The central problem, as defined in the project documentation, was to address the needs of a hypothetical "lazy" instructor who required an automated solution for grading homework assignments. The manual process of evaluating individual student submissions, comparing them against correct solutions, assigning points, and updating a gradebook is time-consuming and prone to inconsistency. The goal was to create a robust Bash shell script application, running within a Linux/Unix environment (specifically PuTTY), that could automate this entire grading workflow for a given homework assignment.

​

​Project Goals

The primary objective explicitly stated: develop a bash application named autoGrader.sh that automatically grades a specified homework assignment. Key required features included:

​

• Utilizing a student roster file (roster.csv ) to identify which students' submissions needed grading.

​

• Executing the instructor's solution code to generate the expected output for comparison.

​

• Executing each relevant student's submission code.

​

• Comparing the student's output against the instructor's expected output for each problem within the assignment.

​

• Calculating a grade for each problem based on the degree of similarity (or difference) between the student's output and the expected output. The documented method involved using the diff command and counting differing lines (wc -l).

​

• Summing the points awarded for individual problems to get a total score for the homework submission.

​

• Adding this calculated total score to a central gradebook file (mainTable.csv ), updating the record for the specific student and assignment.

​

The project focused specifically on demonstrating this functionality for Homework 3 (HW3), although the directory structure included placeholder files for HW1 and HW2 to illustrate a more complete system concept. The project involved two team members and required deliverables, including the code itself and a video presentation demonstrating its functionality. The development environment was PuTTY, executing within a standard Unix-like command-line interface.

My Work

​Project Planning & System Architecture Design

​​

• Planning: Led the initial planning phase, translating project requirements into a workable structure.

​

• Lucidchart: Created the foundational Lucidchart flowchart that visualized the directory structure, data flow, and script logic. This visual plan guided the team's implementation effort.

​

• Tools & Methods Used: Lucidchart, requirements analysis.

​​

• Linkage/Enablement: The Lucidchart provided a clear, shared understanding of the project structure and process, facilitating subsequent directory setup and script development by the team

​

Core Bash Script Development (autoGrader.sh)

​

• Scripting: Authored the majority of the autoGrader.sh script, implementing the primary grading logic. This involved writing Bash code to:​

  • Fetch instructor solutions and student submissions using awk.

  • Dynamically execute the fetched code using eval.

  • Implement the output comparison logic using diff and wc -l.

  • Develop the grading algorithm using conditional statements (if/elif/else) and arithmetic operations to assign points based on output differences.

  • Manage the gradebook update process, including creating temporary files, merging data with paste, and formatting output with column.

  • Incorporate user feedback and pacing elements using echo and sleep.

​

• Troubleshooting: Troubleshooted and debugged the script, occasionally referencing external resources.​​​

​

• Tools & Methods Used: Bash scripting, vi editor, Linux CLI tools (awk, eval, diff, wc, if/then/else, paste, rm, column, etc.), PuTTY environment, debugging techniques.

​​

• Linkage/Enablement: This core script represented the central deliverable, fulfilling the project's main objective. The functioning script processed the data structures set up by the team and performed the automated grading task

​

Code Documentation and Presentation

​

• Detailed Documentation: Authored the detailed documentation within Code.pdf explaining the purpose and functionality of the setup commands and the autoGrader.sh script.

​

• Technical Presentation: Prepared and delivered the main technical portions of the final project presentation, explaining the system's design and functionality.

​

• Tools & Methods Used: Technical writing, presentation software.

​

• Linkage/Enablement: The documentation provided clarity on the project's implementation. The presentation communicated the project's value, design, and outcomes to the intended audience (course professor).

​​

Methodology & Approach

​Project Approach

The team's approach began with a crucial planning phase before significant coding commenced. Recognizing the need for a clear structure, we utilized Lucidchart, a web-based diagramming tool, to create a detailed flowchart. This flowchart served as a visual blueprint, outlining the intended directory structure, the flow of data between different components (student submissions, instructor solutions, grading script, gradebook), and the sequence of operations the autoGrader.sh script would perform. This planning phase, centered around the Lucidchart diagram, was instrumental in providing a clear overview and enhancing team communication and collaboration during the conceptualization stage. Although the final implementation deviated slightly from the initial flowchart due to adjustments made during development, the chart provided the essential "jumping-off point" for the project.
​

Project Development

Following the planning phase, the next step involved translating the conceptual structure into a tangible file system hierarchy within the PuTTY environment. Based on the flowchart, the team systematically created the necessary directories and subdirectories using standard Linux commands like mkdir. This structure deliberately separated concerns, creating distinct top-level directories for Students and Instructor. Within Students, further subdirectories were made for each student (student1, student2, student3), and within each student's directory, subdirectories for each homework assignment (HW1, HW2, HW3) were created. Similarly, the Instructor directory was organized with subdirectories for homework (containing questions, solutions, and expectedOutputs), the main grading script (autoGrader.sh), the overall gradebook (mainTable.csv), and the student list (roster.csv). The tree command was used to visualize this structure during setup.

With the directory structure in place, the team populated it with necessary files using commands like touch (to create empty files) and printf (to insert initial content like headers and data). This included setting up placeholder files for HW1 and HW2, creating the actual questions (HW3questions.csv), instructor solutions (HW3solutions.csv), student submissions (HW3submission.csv for each student with slightly varying answers for testing), the initial mainTable.csv, and the roster.csv. A key file, alice.txt, used as the input text for the homework problems involving grep, was copied into the relevant directories using cp.

The core of the project involved writing the autoGrader.sh script using a text editor (vi) and making it executable (chmod). The script's logic involved fetching instructor solutions and student submissions using awk to parse the CSV files, executing these commands dynamically using eval, comparing the resulting outputs using diff piped to wc -l to count differing lines, implementing conditional logic (if/elif/else) to assign points based on the difference count, calculating total scores, and finally updating the gradebook by creating a temporary column file (new_column.csv), merging it with the main table using paste, and then displaying the result using column before cleaning up temporary files (rm). The script also included echo commands for user feedback and sleep commands to pace the output. Comprehensive documentation was written retrospectively to explain the code.

Key Activities & Execution