Description

Introduction
CP4P students working in groups of 4 will implement, test, and deploy a console application to demonstrate various operations with null-terminated C strings. MS Teams must be used as the collaboration platform. All group members participate in creating an explicit project plan. The C code is provided in the project specifications and uses techniques from the Intro to Programming with C course. Project Application
String Modules Version 1
Required Marks up to:
“C/C+”
Tools: gcc + Version 2
Optional Marks up to:
“B/B+”
Tools: gcc, git + Version 3
Optional Marks up to:
“A−”
Tools: gcc, git Version 3 Pro Optional Marks up to:
“A+”

A Fundamentals fundamentals.h
fundamentals.c Indexing + Measuring + Copying for overall
project quality nearing the
professional level.
B Manipulations manipulating.h
manipulating.c Concatenation + Comparison + Search
C Tokenizing
tokenizing.h tokenizing.c Tokenizing Words + Tokenizing Phrases + Tokenizing Sentences
D Conversions and group leader
converting.h converting.c Converting to int + Converting to double + Converting to long

Each team has three programmers responsible for all aspects of modules A – C, and one programmer / group leader responsible for module D along with synchronizing development and integrating modules into the main application. (D is a less complex module than A, B, or C to balance out the additional leader tasks.)
Application Versions and Deadlines
In Version 1, students implement the functionality in that column as seen in the code shown in _V1.png. In Version 2 – add the functionality noted in that column and as seen in the _V2.png to the previously implemented code in V1. Version 3 adds to V2.
Project Details
C source code for modules in Versions 1 – 3 will be provided as .png (graphics) files. Students will enter their module’s C code, comment it, compile it, create unit test cases, run, and capture the results of tests.
Code for Versions 2+ will be added/integrated into the function previously implemented in version 1. Versions 2 and 3 will use git version control to stage and commit each source code version. Each successive version is cumulative and includes previous version(s).
All group members participate in creating an explicit project plan.
Students communicate and collaborate through MS Teams. A folder within the group’s MS Teams private channel will serve as the project’s code and artifacts (project files) repository.
No programming is required for Versions 1, 2, 3 – only the entry and compilation of the provided source code. The code has little or no input validation; testing notes address this.
Specification documents on commenting, testing, test case template, using git, project management planning template, and video tutorials are provided on Blackboard > Course Documents > Final Group Project.
Evaluation
The maximum marks awarded for a project’s version are representative of the version’s scope. Any submission is evaluated qualitatively, then factored according to its version. For example, A+ quality work for a version 1 project will earn up to C+ range marks, up to B+ range marks for version 2, and up to A+ range marks for version 3. Similarly, C quality work for version 1 will earn marks in the range of 41 – 48% (e.g. 69.4% maximum for version 1 × 0.6 quality = 41.4%). The minimum mark for any submission regardless of version(s) is zero although it would take deliberate carelessness to achieve so little.
The assumption is that all students in a group/team will receive the same grade for each version. Exceptions to this must be noted in the submission comments. Note whether all group members contributed equally and deserve the same marks, or how contributions varied. (e.g. all group members contributed up to V2, but only some did V3) Marks for a project component, e.g. for source commenting or test cases, are an average of all members’ efforts. If two members did a minimal job, and two members did an excellent job, middling marks will be awarded.
Performance and participation expectations and consequences are outlined in the Final Group Project item appearing under Course Documents.

Appendix A Standard Library C Functions used by Modules
Fundamentals Module strlen() // length strcpy() // copy Manipulating Module strcat() // concatenation strcmp() // comparison strstr() // search Converting Module atoi() // string to int atof() // string to double atol() // string to long Tokenizing Module
strtok() // tokenizing

Appendix B Deliverables and Deadlines
All files to be archived in a single zip without a folder structure. Put all files in the root. Use a zip filename which is the same as your group’s Teams channel name. This is submitted to Blackboard via the Final Group Project item under Course Documents.
Version 1 “C+” maximum marks for highest quality (Submission marked out of 100% for quality × .694)
1. fundamentals
a. fundamentals.h – code entered, commented.
b. fundamentals.c – Version 1 code entered, commented, compiled.
c. fundamentals_test_cases.xlsx – comprehensive unit tests to be run, with a record of post-test results.
d. fundamentals_testing.txt – console text captured showing unit test inputs and outputs.
e. forward a, b, c, and d files to team leader
2. manipulating
a. per 1. above
3. converting
a. per 1. above
4. tokenizing
a. per 1. above
5. main.c
a. main.c – code entered, commented, compiled.
b. main_test_cases.xlsx – simple integration tests to be run, with a record of post-test results.
c. main_testing.txt – console text captured showing integration test inputs and outputs.
6. CP4P_Final_Assignment_Plan.xlsx – updated with actual hours and all tasks’ status at time of submission.
7. Team leader assembles all module files from 1 – 4, along with project level files 5 & 6, into a zip archive and submits to Blackboard.
a. Do NOT include .exe or image files.
Version 2 “B+” maximum marks for highest quality (Submission marked out of 100% for quality × .794)
It includes the same files as for Version 1 with Version 2 requirements added to those same files, plus files unique to Version 2.
1. fundamentals – Version 2 tasks and the additional submission file fundamentals_git_log.txt
a. git init, config. See “git basics.docx”
b. git add & commit source code files from Version 1
i. $ git status # should not show “Changes to be committed:”
ii. $ git log # should show a commit, e.g.
commit 3f936d4ce955d7237eebd6e88887dbd6c719bc10
iii. $ git log -p > “fundamentals_git_log.txt” # check contents for
Version 1 details
c. fundamentals.c – Version 2 code added to Version 1 source file, commented, compiled.
d. fundamentals_test_cases.xlsx – comprehensive unit tests to be run for Version 2 code added to Version 1 tests, with a record of post-test results.
e. fundamentals_testing.txt – console text captured showing unit test inputs and outputs.
i. It is necessary to repeat the previous version’s tests in addition to the new version’s test.
Assuming new code added will not affect the existing code is a bad assumption
– that is a frequent cause of bugs in the (less than) professional programming world.
f. git add & commit source code files from Version 2
i. see above as in b. / i. and ii.
g. git log -p > “fundamentals_git_log.txt” # check for Versions 1 & 2 details
h. forward ___.h, ___.c, ____git_log.txt, ____test_cases.xlsx,
____testing.txt files to team leader
2. manipulating
a. per above
3. converting
a. per above
4. tokenizing
a. per above
5. main.c
a. main.c – code entered, commented, compiled.
b. main_test_cases.xlsx – simple integration tests to be run, with a record of post-test results.
c. main_testing.txt – console text captured showing integration test inputs and outputs.
6. CP4P_Final_Assignment_Plan.xlsx – as per above including both Version 1 and Version 2 project plans.
7. Team leader duties – as per above.
Version 3 “A+” maximum marks for highest quality (Submission marked out of 100% for quality) It includes the same files as for Version 1 with Version 1,2, and Version 3 requirements, plus files unique to Versions 2 and 3.
1. Fundamentals – Version 3 tasks
a. fundamentals.c – Version 3 code added to Version 2 source file, commented, compiled.
b. fundamentals_test_cases.xlsx – comprehensive unit tests to be run for Version 3 code added to Version 2 tests, with a record of post-test results.
c. fundamentals_testing.txt – console text captured showing unit test inputs and outputs.
d. git add & commit source code files from Version 3
i. $ git status # should not show “Changes to be committed:”
ii. $ git log # should show a commit, e.g.
commit 3f936d4ce955d7237eebd6e88887dbd6c719bc10
iii. $ git log -p > “fundamentals_git_log.txt” # check for Versions 1
& 2 & 3 details
2. manipulating
a. per 1. above
3. converting
a. per 1. above
4. tokenizing
a. per 1. above
5. main.c
a. main.c – code entered, commented, compiled.
b. main_test_cases.xlsx – simple integration tests to be run, with a record of post-test results.
c. main_testing.txt – console text captured showing integration test inputs and outputs.
6. CP4P_Final_Assignment_Plan.xlsx – as per above including Version 1, 2, and 3 project plans.
7. Team leader duties – as per above.
FAQ
Absolutely not through chat. It is for private, not project communications.
Course Learning Outcomes cross referenced to final project
• Describe the interaction among hardware, system software, and application software, to prepare for the task of computer programming.
o See Project stages. E.g. use of git and installation & use of gcc compiler. Previous installation of software coding editor or IDE.
• Perform a range of computer interaction tasks accurately, using both graphical and commanddriven interfaces, to become a skilled computer user.
o See above.
• Accurately define the functions and services in modern operating systems, to improve decisionmaking when using and programming a computer system.
o Generally inherent in various project tasks. Explicit in overflow protection at Version 3.
• Complete a series of tasks that use and integrate the internet, virtualization, and cloud computing, to complement the capabilities of a network-attached computer/device.
o Microsoft Teams private channel required for project collaboration among group members.
o Github and git.
o (Office 365 tools used throughout the course. E.g. shared news presentation document in another part of the course, some weekly activity assignment required an examination of various collaboration methods, use of OneDrive for backup processes.)
• Assemble a collection of skills, techniques, and best practices to use as an effective software developer.
o Inherent in project requirements for documented PM and SDLC process groups, and in the project planning deliverable.
• Demonstrate how version control and project management techniques are used to improve the productivity and work quality of a computer programmer.
o Requirement to progress through the project’s stages and the use of git version control (the world’s most popular) and explicit project management planning and reporting.