assessment.md

Assessment for Team-Based Project Work

Assessment Key

• N = None
• I = Inadequate
• A = Adequate
• G = Good
• E = Excellent

Technical Skills

Software Development with Python

This section of the document contains the assessment categories related to software development with Python. Every topic includes five levels of competency that will be used to assess students in this class. A wide variety of topics are included that all relate to software development using python. Among these topics are configuring a development environment, using python packages to aid in development, and applying best practices when creating python programs.

• Configuring a development environment for Python
  • N = Unable to setup development environment
  • I = Minimal development environment for Python.
  • A = Basic development environment configured, including proper dependencies and development tools.
  • G = Additional development tools configured, in addition to minimum required dependencies and developments
  • E = Additional development tools configured and able to provide assistance and trouble shooting to other students regarding their own development environment
• Running Python programs with pyenv and pipenv
  • N = pyenv and pipenv not installed or setup
  • I = Unable to run programs with pyenv and pipenv
  • A = Able to run programs with pyenv and pipenv
  • G = Able to run programs with pyenv and pipenv using additional commands and flags as necessary
  • E = Able to run programs with pyenv and pipenv using additional commands and flags to streamline workflow, while being able to provide assistance and trouble shooting to other students using pyenv and pipenv
• Linting Python programs with pylint and flake8
  • N = pylint and flake8 not installed or setup
  • I = Unable to run pylint and flake8 to lint Python programs
  • A = Able to run pylint and flake8 to lint Python programs and successfully address output to ensure program passes pylint and flake8
  • G = Same requirements as level 'A' in addition to understanding other functionalities of pylint and flake8 such as suppressing messages and overrides
  • E = Same requirements as level 'G' in addition to being able to help other students trouble shoot pylint and flake8
• Formatting Python programs with black
  • N = black not installed or setup
  • I = Unable to run black to format Python programs
  • A = Able to run black to format Python programs
  • G = Able to run black to format Python programs with additional command line options if necessary
  • E = Same requirements as level 'G' in addition to being able to help other students with black if necessary
• Basic testing of Python programs with pytest
  • N = Did not utilize pytest
  • I = Found many errors that were not resolved in testing
  • A = Found errors that were not resolved
  • G = Found few errors that were not resolved
  • E = Found minimal errors and resolved most errors
• Advanced testing of Python programs with pytest
  • N = Did not utilize pytest
  • I = Found many errors that were not resolved
  • A = Found errors that were not resolved
  • G = Found few errors that were not resolved
  • E = Found minimal errors and resolved most errors
• Calculating code coverage of a pytest test suite
  • N = Did not utilize pytest for code coverage
  • I = Test suite has low percent of coverage (30 and Below)
  • A = Test suite has moderate percent of coverage (30 - 50)
  • G = Test suite has an acceptable percent of coverage (50 - 80)
  • E = Test suite has a high percent of coverage (80 - 100)
• Reporting code coverage through an online provider
  • N = Did not utilize online provider for code coverage
  • I = Test suite has low percent of coverage (30 and Below)
  • A = Test suite has moderate percent of coverage (30 - 50)
  • G = Test suite has an acceptable percent of coverage (50 - 80)
  • E = Test suite has a high percent of coverage (80 - 100)
• Using docstrings to document a Python program
  • N = Student did not use docstrings
  • I = Students incorrectly attempted docstrings unidentifiable to compiler
  • A = Student added docstrings, but it does not fully prescribe the functions/ methods effect as a command
  • G = Student successfully added docstring with useful description, but is lacking some proper syntax
  • E = Student successfully added docstring with useful description and proper syntax
• Adopting and applying appropriate naming conventions
  • N = Student used inappropriate naming styles that are neither prescriptive or descriptive
  • I = Student used inappropriate naming styles that are either not prescriptive or descriptive
  • A = Students used appropriate naming styles that are not entirely conventional
  • G = Student used appropriate naming styles, but is missing syntax used with variables, function, and methods
  • E = Student used appropriate naming styles with correct syntax used with variables, functions, and methods
• Using exception handling to create a robust Python program
  • N = Student does use exception handling for the possibility of unexpected user input
  • I = Student introduces try and except statements but does not have any clause
  • A = Student utilizes try and except statements or user defined exceptions, however, clause does not function
  • G = Student correctly codes exception handling, but clause doesn't fully execute
  • E = Student correctly codes exception handling with clause being perfectly executed
• Refactoring a Python program to improve its characteristics
  • N = No refactoring done or changed functions completely
  • I = Lack of documentation and clearly identifiable functions/code
  • A = Some changes can be made but well documented
  • G = Includes easy to understand functions and documentation
  • E = Clean and efficient code that is well documented
• Debugging Python programs using logging and other methods
  • N = No debugging done
  • I = Identified bugs in system but no fix
  • A = Fixed some identified bugs using logging/other methods
  • G = Fixed most identified bugs using logging/other methods
  • E = Fixed all or most bugs using multiple methods
• Adopting and using appropriate Python language constructs
  • N = No written code or monolithic code
  • I = Language constructs used inappropriate way
  • A = Some language constructs used appropriately
  • G = Some or many language constructs used efficiently
  • E = Several language constructs used efficiently and reason is documented

Project Management with GitHub

• Using the issue tracker
  • N = None would indicate that someone did not use the issue tracker.
  • I = Inadequate would indicate that an issue is posted but it is either redundant or incomprehensible. Ex. Ajssjdjssd(incomprehensible) or posting that a program's main method is broken when three other people have done the same thing.
  • A = Adequate would indicate that the issue posted is neither redundant nor incomprehensible, but isn't descriptive or clear. Ex. Your program is broken.
  • G = Good would indicate that the issue posted is neither redundant nor incomprehensible, and is moderately descriptive and clear. Ex. Your math function is broken.
  • E = Excellent would indicate that the issue posted is neither redundant nor incomprehensible, and is detailed and easy to understand and follow. Ex. Your math function is broken because you forgot a semi-colon. Error messages from the terminal can also be incorporated. Ex Terminal said that the function was given too many arguments.
• Using the GitHub flow model
  • N = None would indicate that someone pushed directly to the master branch instead of pushing to one of the subbranches. Additionally, they had nonsensical commit messages, and did not create or use repository branches or forks correctly, and also performed incorrect merges and pull requests.
  • I = Inadequate would indicate that forks, and repositories are made correctly. Additionally, merges and pull requests are done correctly and the commit messages can be understood, but the programmer pushed to the master branch.
  • G = Good would indicate that the issue posted is neither redundant nor incomprehensible, and is moderately descriptive and clear.
  • A = Adequate would indicate that the programmer correctly made subbranches and did not push to the master branch. Merge and pull requests are done correctly, commit messages can be understood. Additionally, all forks and repositories were made correctly as well.
  • E = An excellent branch would be a purposeful branch that has a descriptive label. Had strong commit messages, in addition to using and creating repository branches, forks, and pull request correctly.
• Creating and using a repository branch
  • N = Routinely committing edits to the master branch or not pushing to correct branches receives a none grade
  • I = Creating branches with unclear names and no descriptions will receive an inadequate grade
  • A = Branches named sensibly with unique code and descriptions that adequately describe the branch's purpose receive an adequate grade
  • G = Well documented changes to correct well-named and necessary branches will receive a good grade
  • E = Immaculately documented changes on branches that serve extremely important purposes will receive an excellent grade
• Creating and using a repository fork
  • N = Pushing to the wrong fork or making forks that serve no purpose will receive a none grade
  • I = Forks with unclear names and purposes will receive an inadequate grade
  • A = Creating and pushing to forks that are necessary to our design that have detailed annotations will receive an adequate grade
  • G = Highly detailed forks with well-kept history and well-annotated code will receive a good grade
  • E = Immaculately detailed forks with an impeccably annotated history will receive an excellent grade
• Merging a branch or a fork to another branch or fork
  • N = Not communicating changes before merging branches and forks receives a none grade
  • I = Merging with lackluster communication with the team or merging faulty code receives an inadequate grade
  • A = Communicating changes with the team and reconciling differences between code receives and adequate grade
  • G = Merging branches after extensive communication with the team receives a good grade
  • E = Immaculately detailed code and communication with the team before merging receives an excellent grade
• Creating and reviewing a pull request
  • N = no PR was made
  • I = A PR was made but does not tag the related issues it is trying to close, does not fully describe the proposed changes within the PR, and does not update documentation to reflect the changes within the PR
  • A = A PR was made that tags any related issues it is trying to close, fully describes all of the proposed changes within the PR with no review being made by a person
  • G = A PR was made that tags any related issues it is trying to close, fully describes all of the proposed changes within the PR with a review of it that partially discusses the ramifications of the PR after successfully building with Travis CI
  • E = A PR was made that tags any related issues it is trying to close, fully describes all of the proposed changes within the PR with a review of it that fully discusses the ramifications of the PR after successfully building with Travis CI
• Using appropriate commit messages
  • N = None would indicate that the commit message was nonsensical. An example of this would be random strings of letters 'sdhjhsdjsd'.
  • I = Inadequate would indicate that the commit message wasn't nonsensical, yet it was still ultimately uninformative. An example of this would be I am so angry or Please work.
  • A = Adequate would indicate that the commit message both made sense and was descriptive, to an extent. An example of this would be X.py is broken. or I added lines to the main method
  • G = Good would indicate that the commit message was both clear, and moderately descriptive. The main method of X.py is broken. or created three new variables in the main method
  • E = Excellent indicates a adequately detailed and clear commit message. The main method isn't calling correctly or created three ints in the main method

Continuous Integration with Travis

• Setup and configure Travis CI
  • N = Fails to perform any setup and configuration of Travis CI
  • I = Setting up and configuring Travis CI which performs no checks
  • A = Sets up and configures Travis CI without performing checks on all relevant project deliverables
  • G = Sets up and configures Travis CI to perform most relevant checks on project deliverables
  • E = Correctly sets up and configures Travis CI to perform all relevant checks for project deliverables
• Perform secure releases of project deliverables
  • N = Does not utilize Travis CI when releasing project deliverables
  • I = Performs a release through Travis CI which is not secured
  • A = Performs a release through Travis CI which is mostly secured
  • G = Performs a secure release through Travis CI while failing to sign commits
  • E = Utilizes a fully encrypted Travis CI to perform a secure release
• Create third-party integrations with Travis CI (e.g., codecov.io)
  • N = No attempt to incorporate a third party integration
  • I = Third party integrations were implemented but unsuccessful
  • A = A minority of third party integrations were implemented with many errors
  • G = A majority of the third party integrations are successfully implemented with little to no error
  • E = All necessary third party integrations are successfully created without error
• Add README badges that show status of Travis CI builds
  • N = Nothing related to badges was added to the README
  • I = An attempt was made to add a status badge for Travis CI builds but does not work or show up
  • A = A status badge for Travis CI builds is in the README but is not in an appropriate location
  • G = A status badge for Travis CI builds is in the README and is in an appropriate location but not in relation to any other status badges
  • E = A status badge for Travis CI builds is in the README and is in an appropriate location in relation to any other status badges
• Add README badges that show project characteristics (e.g., coverage and language)
  • N = No status badges were added besides one for the build status of Travis CI
  • I = Only some of the relevant status badges were added besides one for the build status of Travis CI
  • A = All relevant status badges were added but are not in appropriate locations
  • G = All relevant status badges were added and are in an appropriate location but not in relation to each other
  • E = All relevant status badges were added and are in an appropriate location in relation to each other and a potentially present status badge for Travis CI builds

Foundations of Software Engineering

• Requirements engineering
  • N = No effort to document, define, or maintain requirements present
  • I = Brief or unspecific documentation, definition, and maintenance given
  • A = Explains what was done with enough detail to convey the most important information
  • G = Documentation and definition are well written and gives other team members an informed idea of the process
  • E = The software engineer displayed highly detailed, elaborate, and complete documentation, definition, and maintenance in the given design process
• Software architecture
  • N = There is no concrete structure and the master branch is broken
  • I = There are small amounts of structure to the code where it may or may not run correctly, and the master branch is broken
  • A = There is a blueprint for the software system that lacks completion, and the master branch is not broken
  • G = There is a completed blueprint for the software system and a working master branch
  • E = The software system contains high-level structures that contain software elements in a complex and complete blueprint of the software system, and the master branch has no errors and contains completed code
• Software design
  • N = No problem solving steps taken
  • I = Initial steps are taken to conceptualize, frame, and implement systems
  • A = Some software design is visible to the point where a software solution looks to be developed soon
  • G = A software solution is created that includes both an algorithm design and a high-level architecture design
  • E = All goals and expectations of the design are met and compatibility, reliability, reusability, and scalability are included while a software solution is ultimately created that includes both an algorithm design and a high-level architecture design
• Software documentation
  • N = No explanation or comments about how to use or how the software works
  • I = A few comments in the code that are not detailed
  • A = Documentation has a bit of detail for every main part of the program
  • G = Documentation is detailed and visible for most of the software within the source code
  • E = Explains in great detail how to use and operate the computer software within the source code
• Programming styles
  • N = Programming style is not set and always changing around during the program
  • I = Not a clear programming style but has some implementation of general styles
  • A = Some clarity of a programming style with multiple styles implemented
  • G = Programming style is implemented well with a few variances throughout
  • E = One distinct style of programming that is clear and easy to understand
• Managing software complexity
  • N = The code does not run properly, files are not in the right place, or some other part of the project has been completely broken
  • I = Little effort is put forth to keep code clean or organized, some code may not work properly
  • A = Basic organization is achieved, no major parts of the projects are affected by any lax in management
  • G = The project is logically and effectively organized with no issues in the code resulting from poor organization
  • E = Everything is exceedingly well organized, with no excess or lack of files, folders, branches, forks, etc.
• Mitigating software risk
  • N = No procedure is followed, the master branch is broken, or files are corrupted
  • I = The engineer avoids causing damage to the work of others, but may not produce any safely compatible source code
  • A = Major issues are avoided and a few small complications may occur, none that ruin the flow of work for the team
  • G = Almost no problems occur while working with code or branches, does not slow down productivity for self or others
  • E = All interactions with new and existing code are free from complications or other issues, everything works smoothly and completely free of errors

Professional Skills

Individual

• Continuous learning about
  • Python software development
    • N = A lack of new knowledge and/or contributions to any project
    • I = Incomplete knowledge or minuscule contributions to projects
    • A = An average amount of knowledge and contributions to each project
    • G = An above average amount of knowledge and contributions to each project
    • E = Going above and beyond the expectations and contributions of others
  • Project management with GitHub, specifically the Flow Model
    • N = A complete disregard for the model, especially multiple instances of overriding the master branch
    • I = Occasional disregard for the model including overriding the master branch
    • A = Almost always adhering to model, but never overriding the master branch
    • G = Making only minor mistakes while trying to follow the model and providing a positive influence on other aspects such as issues and communication
    • E = A lack of mistakes in addition to emerging as a leader who provides support to others who may be struggling with project management
  • Continuous integration with Travis
    • N = Failing to enable Travis at all or not passing any requirements on any assignment
    • I = Enabling Travis, but failing the majority of checks
    • A = Enabling Travis, and passing a majority of Travis checks
    • G = Enabling Travis, and passing all of the Travis checks
    • E = Enabling Travis, passing all checks, and assisting others who are struggling or improving issues with Travis if found
  • Foundations of software engineering practices
    • N = Working separate from a team with no communication
    • I = Working with a team a small amount of the time with no communication
    • A = Working well with a team half of the time with little communication
    • G = Working well with a team most of the time with clear communication
    • E = Working well with a team all time with clear and constructive communication
• Understanding and avoiding red flags
  • N = Ignoring all red flags
  • I = Would be identifying red flags, but not fixing them
  • A = Identifying and fixing a red flag
  • G = Identifying, understanding and fixing a red flag to prevent future bugs
  • E = Identifying, understanding, and fixing all red flags
• Understanding and adopting best practices
  • N = A severe lack of understanding and refusal to adopt best practices
  • I = Slight understanding and occasional use and identification of the best practices
  • A = An average amount of understanding and general identification and use of best practices
  • G = Above average demonstrations of understanding and the ability to find and utilize best practices
  • E = Full understanding of concepts, would also include the ability to determine which practices are better than others and then applying those practices

Group

• Attendance
  • N = Missing five or more lab sessions
  • I = Missing four lab sessions
  • A = Missing three lab sessions
  • G = Missing two lab sessions
  • E = Missing one or less lab sessions
• Deadlines
  • N = If an assignment is turned in 5 or more days past the deadline
  • I = If an assignment is turned in 1-4 days past the deadline
  • A = If an assignment is turned in on the day of, or before the deadline
  • G = If an assignment is turned in on the day of, or before the deadline
  • E = If an assignment is turned in on the day of, or before the deadline
• Communication
  • N = Never check appropriate slack channels and never communicate with teammates
  • I = Rarely check appropriate slack channels and rarely communicate with teammates
  • A = Sometimes check appropriate slack channels and sometimes communicate with teammates
  • G = Regularly check appropriate slack channels and regularly communicate with teammates
  • E = Always check appropriate slack channels and always communicate effectively with teammates
• Participation
  • N = Never participate in group conversation or activity
  • I = Rarely participate in group conversation or activity
  • A = Sometimes participate in group conversation or activity
  • G = Regularly participate in group conversation or activity
  • E = Always participate in group conversation or activity
• Conduct
  • N = Disrespectful and excludes teammates
  • I = Rarely respectful and inclusive of teammates
  • A = Sometimes respectful and inclusive of teammates
  • G = Regularly respectful and inclusive of teammates
  • E = Always respectful and inclusive of teammates
• Decisions
  • N = Never participate in the decision making process and share your opinion.
  • I = Rarely participate in the decision making process and share your opinion
  • A = Sometimes participate in the decision making process and share your opinion
  • G = Regularly participate in the decision making process and share your opinion
  • E = Always participate in the decision making process and share your opinion.
• Postmortems
  • N = Never participate the analysis or discussion after the work is done
  • I = Rarely participate the analysis or discussion after the work is done
  • A = Sometimes participate the analysis or discussion after the work is done
  • G = Regularly participate the analysis or discussion after the work is done
  • E = Always participate the analysis or discussion after the work is done
• Conflicts
  • N = Never handles differences with teammates in mature manner
  • I = Rarely handles differences with teammates in mature manner
  • A = Sometimes handles differences with teammates in mature manner
  • G = Regularly handles differences with teammates in mature manner
  • E = Always handles differences with teammates in mature manner
• Infractions
  • N = Always breaks the team rules
  • I = Regularly breaks the team rules
  • A = Sometimes breaks the team rules
  • G = Rarely breaks the team rules
  • E = Never breaks the team rules

Interactions

• Interaction with the customer
  • N = Does not respect the customer and rejects all their ideas
  • I = Respect customer but rejects most of their ideas
  • A = Respect customer but fails to build a system around their needs
  • G = Respect customer and builds a system around their needs but fails to clearly present your system to your customer
  • E = Respect customer and builds a system around their needs while being able to clearly present your system to them
• Interaction with the team leaders
  • N = Impolite and impatient
  • I = Polite but impatient
  • A = Polite and patient but does not have clear requests
  • G = Polite and patient but does not respond to team leaders
  • E = Polite and patient
• Interaction with the course instructor
  • N = Communicated with the instructor badly, did not follow the project and course requirements
  • I = Communicated with the instructor poorly, followed part of the project and course requirements
  • A = Communicated with the instructor well, followed most of the project and course requirements
  • G = Communicated with the instructor well, followed all project and course requirements
  • E = Communicated with the instructor excellently, followed all project and course requirements
• Interaction with the teaching assistants
  • N = Communicated with the technical leads badly, hate speech, ignore TAs when they are trying to help
  • I = Communicated with the technical leads poorly, did not use them well as your resources, did not talk to them
  • A = Communicated with the technical leads well, but relied on them too much, asked them to do too much work
  • G = Communicated with the technical leads well, politely asked them questions and try to solve the problem with their help
  • E = Communicated with the technical leads excellently, politely sharing own opinions and work with them well

Revision of Guides

• Revising the assessment form: Assessment Sheet
  • N = Not reading the assessment form nor making contributions to it
  • I = Not reading the assessment form in its final state, but making minor contributions thus improving the initial state
  • A = A complete understanding of the assessment form and some contributions in order to enhance it
  • G = A complete understanding of the assessment form and multiple contributions to improve it
  • E = A complete understanding of the assessment form, major contributions, and continuing to improve it throughout the semester as needed
• Revising the code of conduct: Conduct Guide
  • N = Not reading the code of conduct nor making contributions to it
  • I = Not reading the code of conduct in its final state, but making minor contributions thus improving the initial state
  • A = A complete understanding of the code of conduct and some contributions in order to enhance it
  • G = A complete understanding of the code of conduct and multiple contributions to improve it
  • E = A complete understanding of the code of conduct, major contributions, and continuing to improve it throughout the semester as needed