CPSC 480-020 Software Engineering (SE) Fall 2026

Archive

• Week 12 Class 23 Tue Nov 10 Posted: Nov 10

  Announcements

  • No New Rules

    The questions I receive about Project 3 TDD are almost always in the form of general, written hypotheses, such as:

    From these rules, it looks like whenever both a URL and a hash are provided, the URL should take priority in determining the final attribute values. And if the disk filename conflicts with either of those, does the priority system always override it? I want to verify whether this hierarchy is intended to be absolute across all inputs.

    What is happening is that students are trying to state explanations/new rules. This, in general, is not useful. We already have the rules. We do not need an annotated version. Besides, I have to work to understand what you really mean, and I am often unsure that I understand correctly.

    What I rarely get is a test case where the student wants to know if they have the correct output.

    This is useful. I can answer this easily.

    This applies to much more than this problem. Instead of asking if your wordy, difficult-to-understand interpretation is correct, create the test and ask about that. We already have the problem of difficult-to-understand original rules. Don't make it worse.

  • Mock Clock III

    360000? or 3600? These are magic numbers, i.e., numeric literals whose meaning is not clear from the code. In a large project, how would I remember this? What I can easily understand is:

    So why not use this formula? Why did I see people using a calculator for this. The C++ compiler (and the compiler for almost any real language) can compute this at compile time. Why not take advantage of this?

    Why is this important? Because we need to find things in our code. And if you were looking for 100 hours, you would search for the value 100. And when you use cryptic things such as 360000, that doesn't work. Write the program as much as possible using concepts from the problem domain. This includes naming, literal values, strings, etc. Here is an adapted example from the Linux kernel:

    So write these clearly as factors. Let the compiler do the math.

  • Redirecting an Output Stream

    Testing the output of code to std::cout (standard output) or std::cerr (standard error) is not immediately testable in a unit test. We need to "grab" this output and store it in a std::string so we can verify the result. The way to do this is to redirect the output to a string. The following program is an example of how to do that:

    TestStreamOutput

  Class

  • Notes: Refactoring
  • Exercise 52: Software Refactoring I Crossword
  • Exercise 53: Software Refactoring II Crossword
  • HFSD Chapter 10
  • Exercise 54: Team Rename Method Refactoring

  Unless stated otherwise, all exercises are due by 4 pm on Wed Nov 11

• Exercise 54: Team Rename Method Refactoring Posted: Nov 10

  In this exercise, you will go through a workflow to perform a refactoring. The overall process includes:

  1. Setting up an issue at GitHub
  2. Creating an issue branch
  3. Performing the Rename Method refactoring
  4. Creating a pull request
  5. Accepting the pull request
  6. Closing the issue
  7. Deleting the issue branch (but don't do)

  There is no report or uploaded notes. The following workflow must be followed to receive credit. Use the exact commit messages as shown.

  Assignments Invitation Link

  Set Up the Issue

  1. Create An Issue In GitHub, create an issue in your repository for the refactoring. The title of the issue is: Explain what you will do as well as possible for the body of the messages.
  2. Assign Yourself to the Issue Once the issue is created, assign yourself to it so that others know you are working on it.

  Set Up a Branch for the Issue

  1. Create an Issue Branch Instead of working on the branch main, you are going to work on the branch issuen where n is the issue number, e.g., if the issue number is 1 then the branch name is issue1. First, make sure you are in the branch main. Then, create the branch: Branches can be created via GitHub. However, please create this branch via the command line.
  2. You have created a new branch locally, but it does not yet exist at GitHub. To do so, you need to push it to GitHub. When you do so, you will see an error message. Enter the command that it shows you.
  3. Verify at GitHub that your branch exists.

  Perform a Rename Method Refactoring

  1. You are going to perform a refactoring. The code must compile, build, and produce exactly the same result at every commit.
  2. Create a new method declaration in the ToDoList.hpp file. This is not a definition, only the declaration. Compile the program and get it to build successfully. Once done, commit using the commit message: Push your changes to GitHub.
  3. Create a new method definition in the ToDoList.cpp file. This method definition will not have any contents and will return a 0. In other words, the shortest/smallest implementation that will get the program to build. Once done, commit using the commit message: Push your changes to GitHub.
  4. Copy the contents of the old method length() definition to the new method size(). Successfully build the program. Once done, commit using the commit message: Push your changes to GitHub.
  5. At this point, both size() and length() do the same thing. Now, change length() (the old method) to call size() (the new method). The definition of length() should only have the call to size(). Note that you must pass along the parameters and handle any return statements. Once done, commit using the commit message: Push your changes to GitHub.
  6. One-by-one, replace any calls of the method length() with a call to method size(). Again, this must be done one call at a time. After each change, compile, build, and run successfully. Commit each time using the commit message: Push your changes to GitHub
  7. After all calls to length() are replaced, delete the definition (not declaration) of length() in ToDoList.cpp. Compile, build, and run successfully. Once done, commit using the commit message: Push your changes to GitHub
  8. Now delete the declaration of length() from ToDoList.hpp. Compile, build, and run successfully. Once done, commit using the commit message: Push your changes to GitHub.

  At this point, the refactoring is complete.

  Create a Pull Request

  Create a pull request at GitHub. You want to pull from the issue branch into the branch main.

  Accept the Pull Request

  Accept the pull request at GitHub. Typically, this would be done by another team member, but in this case, you can accept your pull request.

  Switch to the main branch in your cloned repository and pull the changes. The rename should appear in the code on the main branch.

  Close the Issue

  1. At this point, you have completed the issue and can close it. Do so at GitHub.

  Delete the Branch

  1. The issue branch has done its job and is no longer needed. All your commits on this branch are now in the branch main.
  2. We could delete this branch, but do not do so for purposes of this assignment.

• Week 11 Class 22 Thu Nov 05 Posted: Nov 05

  Announcements

  • Exercise 49: Project 3 Feedback 2 Check for two rules implemented.

    Overall observations:

    • if-statements that do not follow the coding style
    • Violations of the one call to addAttribute() per attribute, e.g., only one call to addAttribute("filename", /* ... */).
    • Number of if-statements more than the number of rules
    • Unnecessary else's
    • Inconsistent identation that does not follow the coding style

  Class

  • HFSD Chapter 9
  • Exercise 50: HFSD Chapter 9 Crossword
  • Notes: Refactoring

  • Exercise 51: Team Mock Clock III

    In this course, we try to balance two goals: helping you learn the concepts clearly and giving you experience with how real software development is done. In this exercise, some parts are designed to feel closer to real-world practice:

    • Instead of being told exactly what change to make, the required change is written up as an issue—just like it would be in a real project.
    • Your commit messages do not include which approach you are using (dip or mock); they focus only on the change itself.
    • The updates to the CMake build system are provided as a pull request, and you review and work with it like you would on a real team.

    Other parts of the exercise are included mainly for learning purposes:

    • You use two separate branches (dip and mock) to explore different approaches. In an actual project, you would pick one of these approaches and use it on a single branck that is not named after the approach.
    • In real development, you would create a feature branch for the issue and submit a pull request to merge your work into main. For the exercise, the structure is simplified so you can focus on the concepts.

  Unless stated otherwise, all exercises are due by 4 pm on Fri Nov 06

• Exercise 51: Team Mock Clock III Posted: Nov 05

  If you haven't completed the previous Mock Clock exercise, do so before completing this one.

  A team member created an issue in your repository. You have been asked to add a test for this issue. Go to the Issues for your repository at GitHub and read it.

  Session Testing

  Record In your notes, explain why you cannot practically write a test for this issue without using dependency inversion.

  Session Testing with DIP

  1. Move to the branch dip. Verify that you are on the correct branch.
  2. As you work on this branch, record a list of git commands you entered. Order does not matter, and you don't have to repeat them.
  3. Create a new Clock in the files Issue2Clock.hpp and Issue2Clock.cpp, and a test program in the file SessionIssue2Test.cpp. You will need to add these files so that Git will version control them: Do not commit yet.

  4. There is a pull request for the branch dip that has an updated version of CMakeLists.txt that knows about the SessionIssue2Test files. At GitHub, accept that pull request. You will then need to git pull to see the changes in your clone repository in the branch dip.

  5. Create a minimal test program in SessionIssue2Test.cpp. This body of the main should be assert(false) with a return. Make sure the test builds and runs, but it will fail.
  6. Complete the verification with the test program and the new clock.

  7. Commit your work with the commit message:

  Session Testing with DIP and Mock

  As you work on this branch, record a list of git commands you entered. Order does not matter, and you don't have to repeat them.

  Repeat the Session Testing with DIP, but this time on the branch mock. Note the following:

  • The files Issue2Clock.hpp and Issue2Clock.cpp are not needed
  • The pull request is for the branch mock

  Commit your work with the commit message:

• Week 11 Class 21 Tue Nov 03 Posted: Nov 03

  Announcements

  • Project 1 Updated scores, based on your improvements, are in Brightspace. Original scores are also there.
  • Exercise 45: Team Mock Clock Will be graded as part of Team Mock Clock II.

  • Exercise 46: Project 3 Feedback 1

    The feedback for this exercise (and your first commit to Project 3: Code Analysis TDD) is in the feedback branch of your repository with scores in Brightspace.

    Just a clarification: if you receive a 10 / 10 on this exercise, it does not mean you get 100% on that part of the project. It means that you followed the procedure. See the feedback branch to see if I noticed any other issues.

    Also, further exercises for the progressive due dates may not provide feedback on the commit messages, content of the commit, etc. Only on the number of test cases, which should equate to the number of rules implemented.

    If I pointed out issues in the GitHub feedback, you can fix those in separate commits, using the commit message that starts with "Fix".

    General Comments:

    • The commit message should not mention the test. In a TDD process, we assume the test with every commit that adds functionality.
    • The build directory must not be in the repository
    • Indentation is a fixed indentation size: 4, 8, 12, 16, … or 8, 16, 24,…. Do not indent 4 then 2 spaces. Fix this immediately. And, if you do so in the future, it is a 0 for that exercise and that part of the project.
    • Each rule must have a separate test. Make the test the simplest that you can to test the feature.
    • Each test specifies the input (the settings of the fields in the request) and the output (the string returned from formatAnalysisXML()). Use of find(), or substring checking is not part of the test case. Do not make your test case have more complexity (i.e., number of conditions) than your implementation
    • Keep in mind the rule about a single attribute output, unit.addAttribute(), for every unique attribute.
    • Follow the exact code formatting and style
    • Perform refactoring as part of the test and implementation of every commit
    • Treat each rule implementation (and its corresponding commit) as the last commit you will make to this repository. There is no "cleanup" stage that is not part of a TDD commit.

    • Think before every commit:

      • ✓ Added a new test to the test file
      • ✓ Added implementation to get that test to pass
      • ✓ All tests still pass
      • ✓ Refactored the code given the refactoring guidelines
      • ✓ Style of the added tests and implementation follow the coding style of the existing code
      • ✓ Did not add any incorrect files. For Project TDD, this means adding no files.
  • Project 3: Code Analysis TDD Remember the deadlines

  Class

  • Git Commit Messages
  • Exercise 47: Git Commit Messages Crossword
  • HFSD Chapter 9
  • Exercise 48: Team Mock Clock II

  Unless stated otherwise, all exercises are due by 4 pm on Wed Nov 04

• Git Commit Messages Posted: Nov 03

  The article How to Write a Git Commit Message has guidance on commit messages in general and Git projects specifically. Especially note the 7 rules. As the writeup mentions, these ideas are not new.

  A message with only a subject line is adequate for our projects. The rules that only concern the subject are:

  • Limit the subject line to 50 characters
  • Capitalize the subject line
  • Do not end the subject line with a period
  • Use the imperative mood in the subject line (command or instruction)

  Make sure to use these guidelines as you implement any projects or exercises.

• Exercise 48: Team Mock Clock II Posted: Nov 03

  If you haven't completed Exercise 45: Team Mock Clock, do so before completing this one. Notes from this are due at the end of class.

  After that, answer the following questions. Use a couple of sentences (at least) for each of them.

  1. Explain what it takes to add the same test to each of the branches:
     a. main direct testing
     b. dip Using DIP (Dependency Inversion Principle)
     c. mock Using a mock object
  2. Explain the relationship of the real-time clock to the Session class for each of the following. You may want to review the code and examine the UML Class Diagram in Exercise 45: Team Mock Clock.
     a. main direct testing
     b. dip Using DIP (Dependency Inversion Principle)
     c. mock Using a mock object
  3. For each, indicate which of direct testing (main), dip, and mock is the best answer. There can be multiple answers:
     a. Easiest to add a test in terms of time to implement:
     b. Easiest to understand what is going on:
     c. Time to run the tests:

  These questions can be answered after class and are due by 4 pm on Wed Nov 04. Upload a new document with these answers added to your notes for today.

• Week 10 Class 20 Thu Oct 29 Posted: Oct 29

  Announcements

  • Midterm Graded midterm in Brightspace Assignments. Grades only appear in the PDF for now. Overall notes on the midterm are in their also.
  • Guide: Issues with Code Coverage

  • Use the git command line

    • GUI overlays of git are not stable
    • GUI overlays of git often have unintuitive semantics
    • GUI overlays of git can get you into trouble
    • GUI overlays of git are limited in functionality
    • Help and problem solving for GUI overlays of git are limited
    • The git command line is stable and powerful
    • There is a lot of help for the git command line when you have a problem

    You are Computer Science students, many of which will become Software Engineers. Learn your tools. git is your tool. Features in IDEs will come and go.

  • Project 3: Code Analysis TDD

  Class

  • Exercise 44: sortTDD

    Continue to code along in class (or later on) to the sortTDD example. sortTDD Invitation Link

    Class example: sort-tdd-f26-020

  • HFSD Chapter 9

  • Exercise 45: Team Mock Clock

    Mock Clock Invitation Link

  Unless stated otherwise, all exercises are due by 4 pm on Fri Oct 30

• Exercise 45: Team Mock Clock Posted: Oct 29

  The following exercise demonstrates different approaches for testing a Session class. The Session class manages activities over a period of time and then generates a report that includes the session's duration. The session details are not included here, only the reported session length.

  Each approach is on a different branch:

  • Branch main - Session testing without DIP (Dependency Inversion Principle)
  • Branch dip - Session testing with DIP
  • Branch mock - Session testing with DIP using mock objects

  To see what branch you are on, use the git command:

  To switch to another branch, e.g., dip, use the git command:

  To see what files are on that branch, use the bash command:

  Spend a minute switching among the various branches. Use the git branch to verify what branch you are on. If you look at the files on each branch, you will see common files and files that only exist on an individual branch. All necessary files already exist in each branch, so no files are added during the exercise.

  Branch main: Session Testing without DIP

  

  1. Build the code and run the 2-second session test. You can use the time command: Record the timing of three runs of the test program, and note the median value. From the time command, use the real time. Compare the timings to others on your team.
  2. The test for the 5-second session in Session5SecondTest.cpp is incomplete. Complete it following the example in Session2SecondTest.cpp. Build the code, get the test case to pass, and run the 5-second session test: Record the timing of three runs of the test program, and note the median value. Compare the timings to others on your team. Commit your code changes with the commit command:
  3. Let's say we would have a 1-hour session test. Record how long you think it would take to run the test. It should be obvious why we will not have a 1-hour session test using this approach.

  Branch dip: Session Testing with DIP

  

  1. Change to the branch dip. Make sure you are on the correct branch.
  2. View the files Session.hpp, Clock.hpp, Session2Second.cpp, and TwoSecondClock.cpp, and note that instead of the class Session directly using the std::chrono real-time clock, all clock duties have moved to the class Clock. This implies:
     • The class Session now has a dependency on the class Clock
     • This class Clock dependency must be set up when the Session is created
     • The actual clock used is the TwoSecondClock. Build and run the existing test Session2SecondTest. Record the timing of three runs of the test program, and note the median value. Compare the timings to others on your team.
  3. The test for the 5-second session in Session5SecondTest.cpp is incomplete. Complete it following the example in Session2SecondTest.cpp. Build the code, get the test case to pass, and run the 5-second session test: Record the timing of three runs of the test program, and note the median value. Compare the timings to others on your team. Commit your code changes with the commit command:
  4. Now, we can write a practical 1-hour session test. The test for the 1-hour session in Session1HourTest.cpp is incomplete. Complete it following the example in Session2SecondTest.cpp. Build the code, get the test case to pass, and run the 1-hour session test: Record the timing of three runs of the test program, and note the median value. Compare the timings to others on your team. Commit your code changes with the commit command:
  5. Note that this approach to DIP requires a lot of clock classes, one for each timing sequence period.

  Branch mock: Session Testing with Mock Objects

  

  1. Change to the branch mock. Make sure you are on the correct branch.
  2. Writing all these clocks creates a lot of classes. One workaround is to use a configurable clock class, where each clock object can have a different time period. The provided MockClock does just that. Build and run the Session2SecondTest.
  3. The test for the 5-second session in Session5SecondTest.cpp is incomplete. Complete it following the example in Session2SecondTest.cpp. Build the code, get the test case to pass, and run the 5-second session test: Commit your code changes with the commit command:
  4. The test for the 1-hour session in Session1HourTest.cpp is incomplete. Complete it following the example in Session2SecondTest.cpp. Build the code, get the test case to pass, and run the 1-hour session test: Commit your code changes with the commit command:
• Project 3: Code Analysis TDD Posted: Oct 29

  Create your repository Code Analysis TDD Invitation and implement each one of the Rules separately with a single pass through the TDD workflow (red, green, refactor). Each rule (and error message) is implemented in a single commit.

  Due Dates

  The purpose of many class exercises and projects in this class is to practice good workflows of actual, real, 40-hours-a-week software development. Due to time limitations, each part of a project cannot be very long. Treating this as a "race" at the last minute is not part of SE or any good workflow. It tends to produce less-than-optimum software in both external quality, i.e., bugs, and internal quality, i.e., poor design.

  Therefore, the project has progressive due dates regarding the number of rules implemented. Each failure to meet a due date will result in a 10-point reduction in your score out of 100. The following are due dates, not the day you have to work on them, unless you wait until the last day.

  No.	Due Date	Total Rules Implemented	Exercise
  1	Monday, Nov 2 11:59:59 pm	1	46
  	Stop Wait until I provide feedback on your initial workflow by giving you a score for the corresponding exercise. If you don't see a comment, I have not examined your first commit. If you are waiting to continue, send me an email.
  2	Wednesday, Nov 4 10:00:00 pm	2	49
  3	Thursday, Nov 5 10:00:00 pm	3	52
  4	Friday, Nov 6 10:00:00 pm	4	53
  5	Monday, Nov 9 10:00:00 pm	6	54
  6	Tuesday, Nov 10 10:00:00 pm	7
  7	Wednesday, Nov 11 10:00:00 pm	8
  8	Thursday, Nov 12 10:00:00 pm	9
  9	Friday, Nov 13 10:00:00 pm	10
  	Tuesday, Nov 17 11:59:59 pm	All rules and all error messages

  Due dates are given for each step. No work will be accepted after the last due date.

  All commits must appear in the repository on GitHub. Commits or code changes in GitHub Codespaces do not count.

  Project

  The input for a source-code static analysis tool can come from multiple sources, including individual files, e.g., main.cpp, directories of source-code files, e.g., src/, source-code archives, e.g., project.tar.gz, file.zip, and standard input, i.e., stdin, e.g., std::cin. In addition, solitary files and source-code archives can include a URL, e.g., https://mlcollard.net/fragment.cpp

  To perform the code analysis, the source code is wrapped in a single XML element with metadata about the source code, including filename, programming language, URL, hash, LOC (lines of code), and timestamp. For the source code:

  the resulting XML is:

  Note: Scroll to see all the attributes.

  The attribute hash is of the source and is a SHA1 160-bit (20 bytes) represented in 40 hex characters, which is what Git uses. The xmlns:code="http://mlcollard.net/code" is not an attribute but an XML namespace declaration, handled automatically by XMLWrapper.

  The general attribute rules are:

  • The order of the attributes in your output must follow the order above.
  • If the value for an attribute is empty, the attribute is not displayed

  The attribute's variety of input sources and program options follows the Rules stated below.

  Assignment

  Implement the following rules following a Test-Driven Development (TDD) approach. Write a test in CodeAnalysisTest.cpp, implement the minimal code necessary to get it working in CodeAnalysis.cpp, refactor/clean up the code to make it clear and logical, and then commit with an appropriate commit message.

  All commits must result in a program that compiles and passes all tests. This means you must successfully compile and pass the test program before a commit. Any commit that does not build will result in a 0 for that step, and every commit will be checked.

  • The code to implement is in the function formatAnalysisXML().
  • Do not change or create tests for the function filenameToLanguage().
  • Do not create any new functions.
  • Using libraries or including files beyond those already defined is unnecessary and strictly forbidden.

  Rules

  The following rules are unordered. Do not refer to them by number.

  • The minimum LOC is 0. If the option loc is non-negative, add the attribute loc.
  • If you cannot figure out the attribute language based on any other rule, use the default language.
  • When the option hash is not empty, use it for the attribute hash.
  • When the source url is not empty, use it for the attribute url.
  • When used, the option url has priority over the source url for the attribute url.
  • The option language has priority over any other way of determining the attribute language.
  • The option filename has priority over any other way of determining the attribute filename.
  • For a non-archive source-code file, the file extension of the disk filename determines the language, e.g., for the disk filename main.cpp, the language is C++. Use the provided function, filenameToLanguage(), to convert from a filename to a language for the attribute language.
  • For a file in a source-code archive, the file extension of the entry filename determines the language, e.g., for the entry filename main.cpp, the language is C++. Use the provided function, filenameToLanguage(), to convert from a filename to a language for the attribute language.
  • For a source-code archive, use the entry filename instead of the disk filename for the attribute filename.
  • For a non-archive source-code file use the disk filename for the attribute filename.
  • For standard input (i.e., std::cin) of non-archive source code, the disk filename is a single dash "-" and the entry filename is the literal string "data". In this case, you must use the option filename for the attribute filename.
  • For standard input (i.e., std::cin) of a source-code archive, the disk filename is a single dash "-". In this case, use the entry filename for the attribute filename.
  • When the timestamp is not empty, use it for the attribute timestamp.

  Error Handling

  All error messages are written to standard error (i.e., std::cerr) on a separate output line, and the function should return an empty string.

  • If the file extension is used to determine the language, and there is no mapping for that language, output the error message “Extension not supported”
  • When the input is from standard input, and a language cannot be determined, output the error message “Using stdin requires a declared language”

  Workflow

  The workflow for implementing one rule:

  1. Add a single new test case for a single specific rule in the test program CodeAnalysisTest.cpp
  2. Successfully compile and build
  3. Run the test program and verify that the test case fails
  4. Add the implementation only for the new test case in the file CodeAnalysis.cpp
  5. Successfully compile and build
  6. Run the test program and verify that all tests pass, including the new test case
  7. Refactor the test and the added code
  8. Successfully compile and build
  9. Run the test program and verify that all tests still pass, including the new test case
  10. Commit with the appropriate commit message

  Refactoring Guidelines

  All implementation should result in code that is as clean and clear as possible. For this case:

  • Output of a particular attribute must occur only once in the code.
  • Ideally, each rule implementation should only require one additional if-statement.
  • Prefer simple conditions over complex conditions.
  • Prefer initialization and if-then over if-then-else.
  • Separate the logic of calculating an attribute value from the output of the attribute value.
  • Initialize variables on declaration instead of declaring and then initializing.
  • Prefer std::string_view to std::string.
  • Instead of comparing strings to "", use the empty() method.

  Evaluation Environment

  The project is built and graded in a Docker container running srcml/codespaces, which is the same environment as GitHub Codespaces for this project. It is based on Ubuntu 24.04 and uses the GCC compiler.

  On macOS, clang is the default compiler and the one you want to use in most cases. This should not cause a problem with this program. However, before you commit, I recommend ensuring your code can build and pass the tests with GCC and the default compiler, clang.

  Add GCC via homebrew:

  brew install gcc
  

  The preset macos-gcc (in the file CMakePresets.json) provides settings to compile with GCC:

  cmake .. --preset macos-gcc
  

  This preset only appears in macOS and not in Linux or Windows.

  To return to using clang:

  cmake .. --fresh
  

  Instead of flipping back and forth in the same build directory, use two build directories, one for clang and one for GCC. Be sure to build and test in both build directories before you commit. Note It might seem like a pain to have two build directories, but it is not uncommon in real software development and is a good skill to have.

  Grading

  Your score will depend on the following:

  • Meeting the deadlines.
  • Following the TDD process. This must be reflected in your commit history, both when commits are made and the commit messages.
  • Successful implementation of the rules.
  • Following the commit message guidelines.
  • Coding style, including use of if-statements. The function logic should be as simple as possible. Pay attention to the coding style criteria given in class.

• Week 10 Class 19 Tue Oct 27 Posted: Oct 27

  Class

  • HFSD Chapter 8
  • Test Directory Structure Comparison

  • Exercise 43: sortTDD

    Code along in class (or later on) to the sortTDD example. [sortTDD Invitation Link]

    The TDD workflow for this code is:

    0. Run all existing tests on the current code and make sure they pass
    1. Add a single new test case for a single specific rule in the test program sortTest.cpp
    2. Successfully compile and build
    3. Run the test program and verify that the test case fails (red)
    4. Add the implementation only for the new test case in the file sort.cpp
    5. Successfully compile and build
    6. Run the test program and verify that all tests pass, including the new test case (green)
    7. Refactor (if needed) the test and the added code
    8. Successfully compile and build
    9. Run the test program and verify that all tests still pass, including the new test case (refactor)
    10. Commit with a commit message about the added functionality

    Class example: [sort-tdd-f26-020]

    • As suggested by Claude (Anthropic, 2025):

      The goal is the simplest implementation that could work, not the silliest

    • The commit message is about the functionality, not the test case. It should not mention the test. We assume that all functionality added has a test case.

    • There is a commit that you do not see:

  • Exercise 41: HFSD Chapter 8 Crossword

  • Exercise 42: Team Code Coverage II

    • View the feedback for Exercise 40: Team Code Coverage. If you do not view the feedback via the Assignments page, you will get no credit for Exercise 42.
    • Using the feedback, fix/redo any parts that were not correct.
    • Finish up the Exercise 40: Team Code Coverage.
    • Your submitted report should not have any previous incorrect parts.

    As with almost all Team exercises, you must upload your work by the end of class.

  Unless stated otherwise, all exercises are due by 4 pm on Wed Oct 28

• Week 9 Class 18 Thu Oct 22 Posted: Oct 22

  Class

  • srcML Testing parser testfile, libsrcml testfile, client testfile

    So three different parts of testing. But that is not all. There are tests to make sure the installers (Debian packages, rpm's, Windows installers) all work. And tests for any wrappers for libsrcml, e.g., pylibsrcml.

  • HFSD Chapter 8

  • Exercise 40: Team Code Coverage

    • To replace the original Makefile with CMake, the repository has a pull request:

      

      Accept it at GitHub:

      

      If you have problems with this, let me know and I can accept the pull request for your team.

      After the pull request is merged, you will have to git pull to see it in your repository clone.

    • One person cannot commit twice in a row.
    • The assignment is setup for GitHub Codespaces. You are welcome to try on macOS or in Linux (including WSL), but there is no guarantee that it will be setup properly without installing additional packages. If you have an issue on your local machine, turn to GitHub Codespaces.

    As always with Team exercises, due by the end of class.

  Unless stated otherwise, all exercises are due by 4 pm on Fri Oct 23

• Exercise 40: Team Code Coverage Posted: Oct 22

  First, as a team, review the test cases and the code to determine if you achieved 100% code coverage and whether any test cases are not unique and cover the same code. Do not spend much time on this, as you pretty much said so with your previous exercise result.

  The following assumes you are in your build directory.

  Generate a Code Coverage Report

  The tool gcov can, when used with code compiled with the appropriate flags, produce a report that shows exactly how many times each line of code is called during a run of the program. We could use this to determine where our program is taking the most time and perhaps optimize the program. For our purposes today, we can also use it to obtain code coverage. So, we want to run the gcov program with our test program and see the code coverage of the function dotProduct() in the file dotProduct.cpp .

  To produce the gcov report, do the following:

  1. Clean your build
  2. Run cmake to add the option --coverage to the flags provided to the compiler: The CMake variable CMAKE_CXX_FLAGS contains the options passed to the compiler, and CMAKE_EXE_LINKER_FLAGS contains the options passed to the linker. The CMake configuration sets them for things such as Debug and Release builds. The CMake variables CMAKE_CXX_FLAGS_INIT and CMAKE_EXE_LINKER_FLAGS_INIT are the starting values before the CMake configuration sets them.
  3. Run cmake so that make will output the commands it is executing (instead of hiding them from you): The CMake variable CMAKE_VERBOSE_MAKEFILE controls whether make shows the commands it uses to build the program. Note: ninja will not work here. This is one exception to ninja being a drop-in replacement for make. Note that cmake caches its settings. So once you have this configured, you can run CMake again and it will still have these values. They are stored in the file CMakeCache.txt.
  4. Build the program and observe the commands. You should see the flag --coverage. It will occur on every compile and link command. Record in your notes the command for the compile up to and including the --coverage option.
  5. Turn off CMAKE_VERBOSE_MAKEFILE as it is annoying getting that much output with every make command:
     
  6. Run the test program. Do this only once.
  7. This run of the program should produce a file with the extension .gcda. The one you are interested in is dotProduct.cpp.gcda. CMake has an extensive directory structure for the object code, and the .gcda file is with the object code.
  8. Now that you have found the dotProduct.cpp.gcda we must run it through gcov to get the report. Carefully view the output of the program to find where dotProduct.cpp is and the line that starts with Lines executed:. You can safely rerun this command. You will then see how much code coverage your test program produced. Record in your notes this percentage. You should find a file dotProduct.cpp.gcov in your build directory.
  9. To get fresh counts for a new run, delete the .gcda and .gcov files first. A command to do this is (I strongly recommend copy and paste):

  Code Coverage Results

  View the file dotProduct.cpp.gcov in an editor. You will see lines such as:

  Columns are separated by ":". Column 2 is the line number, and Column 3 is the source code. Column 1 is the number of times that line of code was executed, or a - if it is not an executable line (i.e., comment or whitespace). If you see a #####, that means that that line of code was never executed. So, therefore, you do not have 100% code coverage.

  Automation

  Correctly rerunning all of the above commands is repetitive and prone to mistakes. So let's automate it by taking the above lines and making them targets in our CMake. Add the following code at the end of your CMakeLists.txt file.

  Commit this change to the repository with the commit message:

  Any time you make changes to the cmake file CMakeLists.txt, rerun cmake:

  Now, the sequence to run the coverage for the tests is the following:

  Improving the Code Coverage

  To fix this problem, you will have to change the file dotProduct.cpp. Look carefully at the lines of code that were not executed, any conditional statements that had to be true to reach that unexecuted line, and your test cases.

  The change to dotProduct.cpp is to rearrange some lines. Make this change, build the program, run the test program, and make sure the tests still pass. If the tests all pass, commit the change to the file dotProduct.cpp:

  Now, rerun the coverage using our new make targets. Continue making changes to your test cases until you get 100% code coverage. Record in your notes any additional test cases.

  Further Automation

  This sequence is more complex than it needs to be:

  If the build file ran the target coverage-clean before every test, then we would not have to remember to do so. Any knowledge we can put into the build file makes everything easier to repeat. So change (do not just add this code) the test target in the file CMakeLists.txt so that it also DEPENDS on the target coverage-clean:

  Since CMakeLists.txt changed, rerun cmake.

  Now, the new sequence of commands is:

  Automate one more step: change the target coverage-report in the file CMakeLists.txt so that it automatically runs the target test. Then running a new report is a single command, make coverage-report. Rerun cmake and verify that make coverage-report by itself cleans the coverage data, runs the tests, and produces the report.

  Commit these automation changes to the repository:

  Test Cases

  Using the coverage, find the percentage of the code in dotProduct.cpp covered by each test case. Do this by commenting out all but one test case at a time and then running a coverage report. Record in your notes the new percentages and how they compare to what you manually calculated.

• Week 9 Class 17 Tue Oct 20 Posted: Oct 20

  Announcements

  • Professional CMake: A Practical Guide by Craig Scott is the best book on CMake for developers. Besides just covering the CMake features, it also has sections in each chapter with good practices and practical advice. One of the best books of its kind. It was a textbook for CPSC 489-010 T: DevOps in Spring 2024.

    The first 5 chapters are a free download.

    So take a look for any questions on cmake.

  Class

  • HFSD Chapter 7
  • Exercise 37: HFSD Chapter 7 Crossword

  • Guide: assert() and Unit Testing

    add-test-f26-020

  • Exercise 38: AddTest

    Fix the code so that both tests pass. Make sure to commit this separately.

    Then, add another single unit test following the style and formatting of the previous unit tests.

    Make sure it passes all the tests before you commit.

    AddTest Invitation Link

  • Exercise 39: Team Assert Tests

  Unless stated otherwise, all exercises are due by 4 pm on Wed Oct 21

• Exercise 39: Team Assert Tests Posted: Oct 20

  The project, Vector Angle, calculates the degree angle between two vectors. It uses the function dotProduct(). It also includes a test program dotProductTest.cpp.

  As you recall, white-box testing is testing (creating test cases) that knows the structure of the code because it knows the implementation. The test program dotProductTest.cpp includes a single test case using a separate block and an assert().

  Your assignment is to add test cases to the file dotProductTest.cpp and get the tests to run successfully.

  The repository for this assignment is a GitHub group repository. That means there is one repo per team. Assert Tests Invitation Link

  First, build the program:

  Then, run the program:

  The test program is a separate executable, dotProductTest. To run the test program, there is a target, test. So run the test program:

  For this assignment, add tests so that when the complete test program is run, all of the code in dotProduct() is run at least once. This would be 100% code coverage.

  The workflow is:

  • Pull commits so that you start with the most recent version of the files.
  • Add a test case to dotProductTest.cpp that executes at least one line of code that was not executed using the previous test cases.
  • Build the program and deal with any syntax errors.
  • Run the test program and see if it passes. If it does not, then your test case is likely incorrect.
  • Once all tests pass, commit the change using the appropriate commit message.
  • Push the commit and verify that the new test case appears on GitHub.

  Keep in mind the following:

  • Each commit can only add one test
  • The commit message must be: "Add test …" where "…" is filled in appropriately. For the first test case already in the test program, the commit was:
  • No extra test cases are allowed. Do not add a test case covering the same code as another test case.
  • Follow exactly the programming style of the first test case. This includes indentation, formatting, use of whitespace, and blank lines.
  • You will have to push, i.e., git push for the other team members to see your test case.

  I encourage as many team members as possible to commit a test case. If using GitHub Codespaces, each team member has their own codespace. After a team member has entered a test case, the rest can use a git pull.

  Add test cases one at a time to prevent merge issues.

  Each team member must submit notes, including for each test case (not just their own):

  • Parameter values used along with the expected answer
  • LOC (Lines of Code) each test case individually covers. This is a number, not the actual lines. This would be in the function dotProduct() and does not include empty lines or comment lines.
  • The percentage achieved of the total lines of code in the function dotProduct() by this test case

  The notes and commits of each team member are due by the end of the class, along with the test cases. Your score is based on the notes and commits in the team repository.

• Week 8 Class 16 Thu Oct 15 Posted: Oct 15

  Announcements

  Midterm Exam In our regular classroom and at our regular time.

• Week 8 Class 15 Tue Oct 13 Posted: Oct 13

  After Class

  • Project 2 Feedback in GitHub, scores in Brightspace. If your iteration capacity was not correct, I strongly suggest that you figure out what is wrong before the Midterm Exam. Also, You are not allowed to exceed the iteration capacity.

  Announcements

  • Midterm Exam

  • Exercise 34: Team Text Match II

    Some observations regarding team collaboration and outcomes:

    • All team members should have a basic understanding of the technology used. In this case, for building programs: compiling, linking, options, etc. For Make, how to write rules. Some research might be needed, and while some team members may know more about particular points than others, everyone must have a fundamental understanding.
    • All changes must be verified by any means necessary. Many commits included modifications that would cause an error when make is run. Not every team member did this.
    • It was necessary to coordinate who was doing what. The team was in person at the same time, so this should have been straightforward. Consider what would happen if the team were distributed across different work schedules.
    • Allowing the team to only work on the program sequentially wastes ^(n-1)/_n of the potential. There was no reason why the two executables, textmatch and regexCountTest, couldn't be worked on in parallel. Declarative languages are easier to work on independently than other types of languages due to simpler structures. E.g., make is easier to work on independently than C++.
    • The team cannot afford even one member who makes unverified commits, submits changes that aren't aligned with other work, or has limited foundational knowledge.
  • Upcoming Changes to Sign-In: Passkeys and SMS Retirement

  Class

  • Notes: Build Files

  • Guide: Build Configurations

    • How many GCC optimization levels are there?
    • MSVC optimizations /O options (Optimize code)

  • Exercise 35: Build Configurations

    Fill out the Build Configurations table so that it reaches 82,944 different configurations.

    Upload to Brightspace.

  • HFSD Chapter 7

  • Exercise 36: Team Text Match III

    • build-files-f26-020
    • GNU Make
    • Make Rule Introduction What a rule looks like
    • Automatic Variables including $@, $<, and $^
• Exercise 36: Team Text Match III Posted: Oct 13

  In your repository the branch feedback in the file Feedback.md is a Claude (LLM) analysis of the team history for Exercise 34: Team Text Match II. I suggest viewing it at GitHub.

  Read over the analysis and think about what can be improved, not only about your current version of the code, but also about your process. Even if your process worked and you did well, consider how you can parallelize your development (instead of waiting while someone else makes changes).

  Follow the instructions for Exercise 34: Team Text Match II

  The targets are: make clean, make run, make test

  As before, this is due by the end of class. No commits outside of class.

• Week 7 Class 14 Thu Oct 08 Posted: Oct 08

  After Class

  • Project 2 Feedback in GitHub, scores in Brightspace. If your iteration capacity was not correct, I strongly suggest that you figure out what is wrong before the Midterm Exam. You are not allowed to exceed the iteration capacity.

  Before Class

  • Exercise 26: Makefile

    Feedback is in the file Report1.md in the branch feedback in your Build Files repository. You can view this at GitHub. Look where it indicates the current branch, select the branch feedback and you will see the file Report1.md. If you want to compare it, look at the Report1.md from build-files-f26-020.

    We will continue to add to this code in another exercise. If you have lots of problems, then get my current version at build-files-f26-020. Then put that into your Makefile and save it. Finally, commit that to your repository with the following command:

    Do not deviate from this commit message as it will cause problems when I grade it.

  • Exercise 26: Makefile The demo that I did build-files-f26-020 included a diagrams branch with Makefile dependency graphs generated from the current version of the Makefile. This was done via a GitHub Action.

    I decided to add these diagrams to your repository. So if you look at your repo, there is a diagrams branch with a diagram for each commit that changes the Makefile. It is not automated, so as you perform commits it will not automatically update the diagrams, but I will run the script periodically during class.

    To automate this, we would need to add a GitHub Action. That has to be on the main branch, so you would have a commit, and would need to git pull before you made any more commits. To avoid potential confusion, it is not an action.

  Announcements

  • Project 2 Due Friday, Oct 9 at 11:59:59 pm
  • Midterm Exam Thursday, October 15

  Class

  • Exercise 32: Makefile Dependency Diagram

    Using the feedback in Brightspace for Exercise 31: Team Text Match, correct your diagram. If you got a 10 / 10 with the feedback "Correct", you do not have to do anything to receive full credit. For all other cases, correct your diagram or you will receive a 0 on this exercise.

  • Exercise 33: Makefile II

    This is a continuation of Exercise 26: Makefile. Use the same repository as before. Code along and make the same commits with the same commit messages as I do in class.

    build-files-f26-020

    Makefile Dependency Diagram

    • GNU Make
    • Make Rule Introduction What a rule looks like
    • Special Note: recipes are indented using a tab character, not spaces. Using spaces (or an editor that expands tabs to spaces) will result in an invalid Makefile.
    • Automatic Variables including $@, $<, and $^
    • NMake Microsoft's version of Make
    • srcML Playground Generate new srcML of source code, input format for srccomplexity
  • Notes: Build Files
  • Exercise 30: Build Files Crossword

  • CMake

    CMakeLists.txt CMake file for the Build Files example

    To download to your repository:

    Guide: Using CMake

  • Exercise 34: Team Text Match II

  Unless stated otherwise, all exercises are due by 4 pm on Mon Oct 12

• Exercise 34: Team Text Match II Posted: Oct 08

  The utility textmatch finds the number of times a regular expression occurs in a file. Use the same team repository as Exercise 31: Team Text Match, and use your team's dependency diagram as a guide.

  The last person who worked on it was an intern from another university. They entered the build commands in a shell every time they built the program. Of course, you and your team know better, so your team will implement the Makefile for this project.

  Every team member must do one of the following to receive credit:

  • Make commits to the Makefile
  • If you do not have a computer and cannot commit during the team meeting time, then hand write the Makefile on paper and upload to Brightspace by the end of class.

  Restrictions:

  • Add to the Makefile step-by-step following the general procedure used in the Build Files example
  • Do not change any other file
  • Do not use any of the automatic variables until after all the base functionality is complete
  • The number of commits per team member (for those making commits) must be within 1 of the other team members, i.e., as equal a number of commits as possible
  • An individual team member cannot have two commits in a row
  • No commits can be made after class ends

  As your team members make commits, you will have to update your working copy. Use the command:

  Note that your team does not share a GitHub Codespace. All of them are different. You will not see other team members changes until you pull.

• Midterm Exam Posted: Oct 08

  The Midterm Exam is Thursday, October 15, during our regular class time and classroom. It covers Chapters 1 - 6.5 of the Head First Software Development book, plus notes and in-class examples.

  • Big Bang approach to development - description, the path it takes, and disadvantages
  • Iterative approach to development - description, the path it takes, and advantages
  • Role of the customer/client
  • User Stories - all parts, description, creation, valid user story titles
  • Estimates and the Estimation Process, including all details of planning poker
  • Iteration and deadline planning
  • Utopian vs. Real-World days
  • Velocity - description, standard rate, what does it mean if velocity is higher or lower
  • Big Board - basics of what it shows and how developers use it
  • Good-enough design, SRP, DRY
  • Version control - jobs that it does, commit messages, branches (specific git information not on this midterm)
  • Build artifacts - Role and importance (code, configuration, tools), the general purpose of make and cmake. Given a Makefile, what would happen with specific targets. Given a project, draw a build dependency diagram.

  The exam has various problem types, including short answers, definitions, comparisons, creation of user stories, and planning. The question may require you to:

  • Explain a process or terminology of a process
  • Answer specific questions about parts of the process. E.g., "Explain why the recommendation is to come up with user stories whose estimates are 15 or less."
  • Explain what process and activities you would follow for a particular scenario

  It is a good idea to review the "Dumb Questions" and the answers.

  The questions are based on what we covered in the book, the exercises, and the projects. If I did not cover it in class, it is not on the exam.

  A calculator is not needed for any required math and, therefore, not permitted.

• Week 7 Class 13 Tue Oct 06 Posted: Oct 06

  Announcements

  • Office Hours for today (2:30 - 3:30 pm) are cancelled

  • Project 2: Iteration Plan

    Each student must get their own priorities. Do not reuse the ones from the Team Exercises.

  Class

  • Make

    build-files-f26-020

    Dependency Diagram

    • GNU Make
    • Make Rule Introduction What a rule looks like
    • Special Note: recipes are indented using a tab character, not spaces. Using spaces (or an editor that expands tabs to spaces) will result in an invalid Makefile.
    • Automatic Variables including $@, $<, and $^
    • NMake Microsoft's version of Make
    • srcML Playground Generate new srcML of source code, input format for srccomplexity

  • Exercise 26: Makefile

    Code along and make the same commits with the same commit messages as I do in class.

    I suggest you use GitHub Codespaces as all necessary packages are installed.

    Remember that you can access my commits as I make them.

  • HFSD 6.5
  • Exercise 29: Make Crossword

  • Notes: Build Files

    CMakeLists.txt CMake file for the Build Files example

    To download to your repository:

  • Exercise 30: Build Files Crossword Due after next class
  • Exercise 31: Team Text Match

  Unless stated otherwise, all exercises are due by 4 pm on Wed Oct 07

• Exercise 31: Team Text Match Posted: Oct 06

  The utility textmatch finds the number of times a regular expression occurs in a file. The repository for this exercise is a GitHub group repository. That means there is one repo per team. Text Match Invitation Link

  Hand draw a dependency diagram of the Makefile for textmatch:

  • Include every file involved in the build: source files (.cpp), header files (.hpp), object files (.o), and executables
  • Include both executables, textmatch and regexCountTest
  • Include the targets clean, run, and test
  • Draw an arrow from each target to each of its prerequisites
  • To find the header prerequisites, look at the #includes in each file. Only include headers that are part of the project, not system headers such as <iostream>

  As an example, here is the Make prerequisite graph for the srccomplexity program in the build-files-f26-020 example. I suggest you open it in its own tab.

  

  Upload a photo or image of the diagram to Brightspace by the end of class. Each member must upload their own, individual diagram.

• Week 6 Class 12 Thu Oct 01 Posted: Oct 01

  After Class

  • Office Hours today from 2:30 - 3:30 pm are cancelled.

  Before Class

  • If you haven't already created the GitHub Classroom repository for "Build Files" you should do so before class. You can also set up a GitHub Codespace for the project, as it takes some time to start up initially and when restarting.

  • Exercise 25: Build Tools Background

    Please complete before class starts. There are no wrong answers, and not much to write.

  Announcements

  • Project 1 I will allow you to earn some points back by correcting what you submitted. To count:

    • Each item in the feedback must be in a separate commit
    • Each commit message must follow the guidelines we went over: 1) Start with an action, 2) Imperative form, 3) Use the one-line form, 4) Do not end in a period, and 5) Keep it a reasonable length.
    • If an error was made, then create an issue at GitHub in your repository
    • Due at 4 pm on Friday, Oct 2
  • Project 2: Iteration Plan
  • Post Page The main course page is getting quite long. A reminder that the title of each post is a link to a separate page of that post.
  • Version Control We have only covered a high-level view of version control. During the rest of the semester, we will cover it in much more detail as part of dedicated notes and the overall workflow.

  Class

  • Notes: Version Control
  • Exercise 23: Version Control Overview Crossword II Due by 4 pm on Fri Oct 2
  • HFSD 6.5

  • Make

    Build Files GitHub Organization Invitation Link - Create your own repository for this example (and future exercisese)

    • GNU Make
    • Make Rule Introduction What a rule looks like
    • Special Note: recipes are indented using a tab character, not spaces. Using spaces (or an editor that expands tabs to spaces) will result in an invalid Makefile.
    • Automatic Variables including $@, $<, and $^
    • NMake Microsoft's version of Make
    • srcML Playground Generate new srcML of source code, input format for srccomplexity

    build-files-f26-020 Example I will demonstrate with

  • Exercise 26: Makefile

    Code along and make the same commits with the same commit messages as I do in class.

    I suggest you use GitHub Codespaces as all necessary packages are installed.

    Remember that you can access my commits as I make them.

  • Exercise 27: HFSD Chapter 6.5 Crossword
  • Exercise 28: Team Iteration II

  Unless stated otherwise, all exercises are due by 4 pm on Mon Oct 05

• Project 2: Iteration Plan Posted: Oct 01

  Project 2 is due on Friday, Oct 9 at 11:59:59 pm. The GitHub Organization Project 2 Invitation.

  For Project 2, take all the user stories from Project 1 and create a series of iteration plans.

  Use the examples in the book to show which parts of the user story you should show in your iteration plan (e.g., do not restate descriptions in the plans). Also, clearly state the entire new iteration plan for each plan, not just the changes. However, make sure to thoroughly discuss what the change was and what effect it had.

  This is an individual project. Each member of a team has different user-story priorities. To get individual priorities for Project 2, select the number of user stories:

  User Stories:
  

  Put these in the Priority field in the order in which you listed the user stories. In the report, do not discuss how you generated your report's priorities, i.e., pretend that the customer gave them.

  The following plans may require you to add additional user stories. This violates our rule that only the development team can create estimates. However, as part of the exercise, put in an estimate.

  Each plan is a point in time. For each plan, show the entire iteration plan, including the iterations already completed.

  Plan	Events
  1	Create an initial iteration plan: 2 Weeks (14 calendar days) iteration, 2 developers, 0.6 velocity
  2	The customer adds two new user stories of the highest priority at the end of the first iteration. For the two new user stories, one is a new feature, and one is an emergency. Create a non-trivial estimate (i.e., an estimate that makes the planning interesting) for these new user stories.
  3	A user story with a non-trivial estimate takes twice as long. Assume this occurred right before the last iteration.
  4	At the beginning of the last iteration of your current plan, the other developer leaves for another project, and it is up to you to finish the project.

  After the plans, create a section with all of your user stories, including their titles, descriptions, estimates, and priorities. You will need estimates for all of your user stories.

• Exercise 28: Team Iteration II Posted: Oct 01

  Your team completed the first iteration. Despite inexperience with determining estimates, you did complete the all the planned user stories.

  For some of the remaining user stories, not part of the first iteration, the customer updated the priorities of 4 user stories. Get new priorities for these user stories:

  User Stories:
  

  Now, design a second iteration. Use the principles in the book to decide which of the remaining user stories belong in the second iteration.

  Individually, each team member will turn in to Brightspace notes with the following:

  • Details of the calculation of the capacity of the iteration, i.e., how many days of work can be accomplished
  • Set of user stories in the revised first iteration with title, estimate, and priority
  • Set of user stories in the second iteration with title, estimate, and priority
  • Any observations

  Do not assume any dependencies between user stories.

  The notes are due by the end of class. They can be a PDF (print to file from a computing device) or a JPG (picture taken via phone).

  If you finish early, work on real estimates for your user stories.

• Week 6 Class 11 Tue Sep 29 Posted: Sep 29

  After Class

  • Exercise 25: Build Tools Background

    Please complete before class starts. There are no wrong answers, and not much to write.

  • If you haven't already created the GitHub Classroom repository for "Build Files" you should do so before class. You can also set up a GitHub Codespace for the project, as it takes some time to start up initially and when restarting.

  Announcements

  • Project 1

    • Scores are in Brightspace
    • Feedback is in the branch feedback in the file Feedback.md. I suggest you view it on GitHub.
    • Not all the items marked off caused you to lost points. But many did.

    I will allow you to earn some points back by correcting what you submitted. To count:

    • Each item in the feedback must be in a separate commit
    • Each commit message must follow the guidelines we went over: 1) Start with an action, 2) Imperative form, 3) Use the one-line form, 4) Do not end in a period, and 5) Keep it a reasonable length.
    • If an error was made, then create an issue at GitHub in your repository
    • Due at 4 pm on Friday, Oct 2

  • Project 1 Observations

    • Not being careful enough
    • Not doing enough iterations
    • Much inconsistency of the report and what is on the user story cards. This is a major error.
    • Not enough time spent on the general process for estimation. Missing the term "planning poker", not giving the card values, not stating what the process is for forming a consensus, etc.

  • UNIX Commands

    I occasionally use UNIX commands in a bash shell to perform development tasks or to point out the results of development tasks. Obviously there is git, but there are a lot of other commands that we use. We just saw diff and patch.

    I recommend that you keep a list of these commands with the name, short description, and example of using it. These commands will not be on any exam unless I specifically say they are. However, they may be part of a crossword.

  Class

  • Demo: Patching Linux

    • kernel.org
    • kernel v7.x
    • https://www.kernel.org/pub/linux/kernel/v7.x/linux-7.1.tar.gz
    • https://www.kernel.org/pub/linux/kernel/v7.x/patch-7.2.xz
    • https://www.kernel.org/pub/linux/kernel/v7.x/linux-7.2.tar.gz

    explainshell

  • Exercise 22: Patching Linux

    Follow along with the Patching Linux demo shown in class. Write the commands in order as they are applied in the demo.

    For the URLs, copy and paste, or write a shortened form of the URL.

    Upload to Brightspace this list of commands. This can be a text file, or an image of the commands written on paper. This is due by the end of class.

  • Notes: Version Control
  • Exercise 23: Version Control Overview Crossword II Due by 4 pm on Fri Oct 2
  • HFSD Chapter 6.5

  • Make

    Build Files GitHub Organization Invitation Link - Create your own repository for this example (and future exercisese)

    • GNU Make
    • Make Rule Introduction What a rule looks like
    • Special Note: recipes are indented using a tab character, not spaces. Using spaces (or an editor that expands tabs to spaces) will result in an invalid Makefile.
    • Automatic Variables including $@, $<, and $^
    • NMake Microsoft's version of Make
    • srcML Playground Generate new srcML of source code, input format for srccomplexity

    build-files-f26-020 Example I will demonstrate with

  • Exercise 24: Team Iteration

  Unless stated otherwise, all exercises are due by 4 pm on Wed Sep 30

• Exercise 24: Team Iteration Posted: Sep 29

  As a team, create the first iteration of an iteration plan.

  Ideally, we would have enough Team Meeting time to estimate all user stories using Planning Poker. However, we do not. To make up for this, I am providing estimates for the rest of your user stories. Enter the following:

  Current Maximum User Story Estimate: 2 3 5 8 13 20 40 100
  Missing User Story Estimates:
  

  Add these estimates to your user story cards.

  The other missing item is the priorities. These come from the customer. To get priorities, select the number of user stories:

  User Stories:
  

  Add these priorities to your user stories.

  You have 1 developer and a one-month iteration with a 70% velocity.

  Use the principles in the book to decide which user stories belong in the first iteration.

  Individually, each team member will turn in to Brightspace notes with the following:

  • Details of the calculation of the capacity of the iteration, i.e., how many days of work can be accomplished
  • Set of user stories in the first iteration with title, estimate, and priority
  • Any observations

  Do not assume any dependencies between user stories.

  The notes are due by the end of class. They can be a PDF (print to file from a computing device) or a JPG (picture taken via phone).

  If you finish early, use planning poker for estimates on the user stories your team did not estimate earlier.

• Week 5 Class 10 Thu Sep 24 Posted: Sep 24

  Announcements:

  • Tasks

    • Tasks do not have names as titles. They are numbered.
    • Tasks have a (numbered) title, a description, and an estimate. It is essential in software engineering to use proper terminology as much as possible.
    • Only estimates obtained by a team consensus using a planning poker process will be put on tasks (just like with user stories).
    • Tasks are not the process a user would go through. They are what the developer would go through. They are different parts of the implementation of the code.
    • Tasks should be brief. For one thing, they need to fit on a post-it note. Secondly, that extra detail does not help; you would never have enough detail.

  Class

  • HFSD Chapter 6
  • Notes: Version Control

  • Exercise 21: diff and patch

    Write on paper the diff and patch commands of the two sessions, Creation and Application on a piece of paper as I show this in class.

    Due after I show it in class.

  • Exercise 19: Version Control Overview 1 Crossword Due by 4 pm on Wed Sep 30
  • Exercise 20: Team Tasks II

  Unless stated otherwise, all exercises are due by 4 pm on Fri Sep 25

• Exercise 20: Team Tasks II Posted: Sep 24

  As a team, take a user story that has an estimate, and create the tasks for that user story. Then, create the estimate for each task by playing planning poker using the procedure described on pages 48-49 of the book. Go through the estimation process at least one time.

  When the team reaches a consensus for the estimate, place the estimate at the bottom of the task, e.g., "Estimate: 1 day" or "Estimate: 3 days".

  Individually, each team member will turn in to Brightspace individual notes that include for each round of planning poker:

  • Title of the user story, task title, and description of the task
  • Any questions on or confusions with the user story/task
  • Any assumptions that you made
  • Any interesting assumptions that other team members made
  • The spread of estimates, indicating which one is yours
  • The final estimate, which is a team consensus (if the team was able to reach one in this round)

  If the team cannot reach a consensus, table that task and go on to another one.

  The notes are due by the end of class. They can be a PDF (print to file from a computing device) or a JPG (picture taken via phone). The notes are for today only. Do not start with the notes from the previous team meeting.

  The more you work with the user stories, the more you will find improvements to them. Be sure to make those improvements.

• Week 5 Class 9 Tue Sep 22 Posted: Sep 22

  Announcements:

  • Project 1 The screencast for using asciinema is for an old version. I will demonstrate in class on Tuesday how to run it. The due date for the URL of the asciinema session is extended to 11:59:59 pm on Tuesday, Sep 22. The due date for the project commits to GitHub stays the same. I am going to not require this for Project 1. More details later.

  Class

  • HFSD Chapter 4
  • Exercise 17: HFSD Chapter 4 Crossword
  • HFSD Chapter 5
  • Exercise 18: Team Tasks

  Unless stated otherwise, all exercises are due by 4 pm on Wed Sep 23

• Exercise 18: Team Tasks Posted: Sep 22

  As a team, take a user story that has an estimate, and create the tasks for that user story. Then, create the estimate for each task by playing planning poker using the procedure described on pages 48-49 of the book. Go through the estimation process at least one time.

  When the team reaches a consensus for the estimate, place the estimate at the bottom of the task, e.g., "Estimate: 1 day" or "Estimate: 3 days".

  Individually, each team member will turn in to Brightspace individual notes that include for each round of planning poker:

  • Title of the user story and task
  • Any questions on or confusions with the user story/task
  • Any assumptions that you made
  • Any interesting assumptions that other team members made
  • The spread of estimates, indicating which one is yours
  • The estimate, which is a team consensus (if the team was able to reach one in this round)

  If the team cannot reach a consensus, table that task and go on to another one.

  The notes are due by the end of class. They can be a PDF (print to file from a computing device) or a JPG (picture taken via phone). The notes are for today only. Do not start with the notes from the previous team meeting.

  The more you work with the user stories, the more you will find improvements to them. Be sure to make those improvements.

• Week 4 Class 8 Thu Sep 17 Posted: Sep 17

  After Class

  • Project 1 The screencast for using asciinema is for an old version. I will demonstrate in class on Tuesday how to run it. The due date for the URL of the asciinema session is extended to 11:59:59 pm on Tuesday, Sep 22. The due date for the project commits to GitHub stays the same.

  Announcements

  • Exercise 13: Commit to Project 1 Repository

  • Project 1: Requirements Report

    • Include all user stories, even those without estimates. If a user story does not have an estimate, leave the estimate value blank.
    • Project 1 is not a team project. They only thing that you share with your team is the user story cards. Everything else originates from you. Do not set a team template for this.
    • This is a report about the team results and process, not your individual results and process.
    • The first two sections will be shown to the customer. Those sections should only contain information the customer is allowed to see. You will lose a significant number of points if you do not follow this rule.
    • All user stories belong to the team. This is a report of the current state of your team project.
    • There is no "my user story". All user stories belong to the team, actually the customer.
    • The customer is not interested in tasks, only the user stories.
    • The report should be readable and consistent both in markdown and displayed as a web page at GitHub.

  • Project 1 asciinema session The asciinema session is after you complete Project 1. Since you are still performing estimation, you are not done with the user stories for Project 1.

  • Estimates

    • Estimation in software development is not about finding the minimum time it would take you to complete a user story. It's about understanding and predicting the genuine effort required in the context of a 5-day week 50 weeks a year. Remember, an estimate is not a speed challenge but rather a measure of how long it will realistically take to completely implement a user story.
    • Avoid the trap of only considering the quickest or simplest implementation. Proper estimation requires thoughtful consideration of all possible complexities. Moreover, completing a user story quickly doesn't mean the rest of the day is free; there's always another user story waiting. This is not a class assignment or a lab exercise where once you are finished you are done for the day.
    • Refrain from using phrases like "All we have to do …” when discussing software tasks. Such assumptions oversimplify the complexities of coding.

  Class

  • HFSD Chapter 3
  • Exercise 14: HFSD Chapter 3 Crossword
  • HFSD Chapter 4
  • Exercise 16: Team User Story Estimates II

  Unless stated otherwise, all exercises are due by 4 pm on Fri Sep 18

• Exercise 16: Team User Story Estimates II Posted: Sep 17

  Start by reviewing your user stories, particularly the titles. Titles that do not have an action term, or have a poor action term, will reduce your score on Project 1.

  As a team, create estimates for the user stories by using the planning poker procedure described on pages 48-49 of the book.

  When the team reaches a consensus for the estimate, place the estimate at the bottom left of the User Story as indicated by the example, e.g., "Estimate: 1 day" or "Estimate: 3 days".

  Individually, each team member will turn in to Brightspace individual notes that include for each round of planning poker:

  • Title of the user story
  • Any questions on or confusions with the user story
  • Any assumptions that you made
  • Any interesting assumptions that other team members made
  • The spread of estimates, indicating which one is yours. Be very careful with this, and note that a spread is on a number line.
  • The estimate, which is a team consensus (if the team was able to reach one in this round)

  If the team is not able to come to a consensus, table that User Story and go on to another one.

  The notes are due by the end of class. They can be in the form of a PDF (print to file from a computing device), or a JPG (picture taken via your phone).

  The more you work with the user stories, the more you will find improvements to them. Be sure to make those improvements. Also, you may think of additional user stories. Be sure to add them.

• Week 4 Class 7 Tue Sep 15 Posted: Sep 15

  Announcements:

  • Exercise 11: GitHub Username

    There are three steps to allow you to create repositories for the projects and some of the exercises:

    1. You provide your GitHub username
    2. I add you to the roster of the course in Classroom 50 (already completed for those who provided their GitHub username)
    3. GitHub sends you an invitation to become a member of the UACPSC organization, and you accept it.

    For 3, I indicated in your feedback for Exercise 11 if this was not accepted yet, then you need to accept the invitation

    Invitations are email to the email account for your GitHub Username. I assume in most cases this is your UA email.

    You can also view these on your GitHub Organization Page

    If you accept the invitation, I will give you full credit for this exercise.

  • Windows File Explorer & WSL

    To open the Windows File Explorer on the current directory in WSL:

    The . means the current directory in WSL. You can also open a file explorer.exe Requirements.md. If you open a path it has to be in Linux format, e.g., C:\Users\JohnDoe\Documents would be /mnt/c/Users/JohnDoe/Documents.

  • Assumptions

    I noticed that many of the assumptions mentioned are about the difficulty of implementation. This is not what the book discusses. Instead, they are assumptions about what the user story means. The only person who can answer those assumptions is the customer.

    From now on, label assumptions about the user story as assumptions and assumptions about implementation as implementation.

  • Dependencies

    I see a lot of user story estimates where the assumptions include the completion of a previous user story. This is a dependency. Avoid dependencies at all costs. For example, Add … does not have to be completed before Delete …. Obviously there will be some dependencies, but they are to be at the user-story level, not the implementation level.

  Class

  • GitHub Codespaces
  • GitHub Authentication
  • Creating the Report
  • Git Commands The table will expand as we use more commands

  • Exercise 13: Commit to Project 1 Repository

    Following the procedure given in the assignment and demonstrated in class, contribute at least one commit to the Project 1 repository. This must be a valid and useful commit.

    • Use the git CLI to make the commit. You can do this wherever you have the repository cloned. You can even do this in a GitHub Codespace
    • Good commit messages follow certain patterns, and you need to follow them on all git commits:
      • Start with an action, e.g., Add
      • Capitalize the subject line (the only line we are using)
      • Use the imperative mood, e.g., Added, Adding, Adds, Add
      • Do not end the subject line with a period

    You can see your commit messages with the git log command.

  • HFSD Chapter 3
  • Exercise 14: HFSD Chapter 3 Crossword Due by 4 pm on Friday, September 18
  • HFSD Chapter 4
  • Exercise 15: Team User Stories III

  Unless stated otherwise, all exercises are due by 4 pm on Wed Sep 16

• Exercise 15: Team User Stories III Posted: Sep 15

  Your management is concerned that your team does not have a complete set of user stories. The first problem is low recall, i.e., the team is not capturing all the user stories the customer needs. The second problem is that without not enough work, the organization will have to let some of the team members go cut everybody's pay.

  The customer met with their team and returned with a list of potential user-story titles. These possible new user stories fall into one of the following categories:

  • An existing user story
  • Not a user story title
  • New, but needs to be converted from plural to singular
  • New, but needs to be split into multiple stories
  • Not part of the description

  Each team member will fill out the form for your team. The form will not be available until your team meeting time.

  • Count Dooku
  • Ewoks
  • Leia
  • Watto

  Create a new user story, or multiple user stories, for each of these valid potential user stories. This includes fixing any title issues and adding a description. Also, take this time to fix any existing user stories.

  If you have any additional time, then create more estimates. As you did before, keep track of details for the next team meeting when you will submit any estimate details.

  There is nothing to upload for this exercise. Complete the provided form during class time.

• Week 3 Class 6 Thu Sep 10 Posted: Sep 10

  After Class

  • Exercise 11: GitHub Username

    There are three steps to allow you to create repositories for the projects and some of the exercises:

    1. You provide your GitHub username
    2. I add you to the roster of the course in Classroom 50 (already completed for those who provided their GitHub username)
    3. GitHub sends you an invitation to become a member of the UACPSC organization, and you accept it.

    For 3, I indicated in your feedback for Exercise 11 if this was not accepted yet, then you need to accept the invitation

    Invitations are email to the email account for your GitHub Username. I assume in most cases this is your UA email.

    You can also view these on your GitHub Organization Page

    If you accept the invitation, I will give you full credit for this exercise.

  • Project 1 Invitation Link

    Note that the link (in the title of this this notice) will only work if you:

    • Provided me with your GitHub username (Exercise 11)
    • I entered you into the roster
    • You are a member of the UACPSC GitHub Organization (you accepted the invitation)

  Announcements:

  • Similar Action Words

    Many action words are similar in meaning, but can vary in specificity or in details that they imply.

    Word 1	Word 2	Explanation
    Delete	Remove	"Delete" often implies a permanent action, while "Remove" can be less final or reversible
    Approve	Accept	"Approve" sounds authoritative, while "Accept" is more general
    Invite	Connect	"Invite" is very specific, suggesting a request for participation, whereas "Connect" is broader
    Create	Add	"Create" is making something new, whereas "Add" can mean including something that already exists
    Subscribe	Register	"Subscribe" is ongoing engagement, while "Register" is often a one-time action
    Approve	Validate	"Approve" is a decision or permission, while "Validate" suggests checking or confirming correctness
    Merge	Link	"Merge" is combining into one, whereas "Link" connects them without combining
    Submit	Send	"Submit" is submission to a process, while "Send" is transferring information
    Stop	Pause	"Stop" is final, while "Pause" is temporary
    Cancel	Stop	"Cancel" is preventing something from starting or finishing, whereas "Stop" is halting an ongoing action

    Note that the customer may not realize the difference between these terms, and say one when they mean the other.

  • Exercise 11: GitHub Username GitHub Classroom is no more. Instead, we are using Classroom 50. The process for allowing you to create a repository has changed and is as follows: 1) Add you to the UACPSC GitHub Organization, and 2) Add you to the roster for the course. To do so, I need your GitHub Username. If you don't provide it, you won't be able to do the projects and some exercises.

    The title of this exercise is a link to the form where you can enter your GitHub Username.

    Once I add you to the roster, you will receive an invitation to join the UACPSC GitHub Organization. You will need to join in order to create repositories. Note that this differs from the GitHub Classroom process of the past.

    Due Friday, Sep 11 by 9 am.

  • GitHub Authentication

  Class

  • Project 1: Requirements Report
  • HFSD Chapter 3
  • Exercise 12: Team User Story Estimates

  Unless stated otherwise, all exercises are due by 4 pm on Fri Sep 11

• Project 1: Requirements Report Posted: Sep 10

  Project 1 is due Monday, September 21 at 11:59:59 pm, in the file Requirements.md in a GitHub Organization UACPSC repository. You will need a GitHub account, give me your GitHub Username, and accept the invitation to join the GitHub organization UACPSC. Once you are all setup, an invitation link to create the repository is in Brightspace.

  Description

  At your place of work, you need to submit a formal report describing the project's current state. Write a report of your individual and team activities, including these primary sections:

  1. User Stories

  User Stories with title, description, estimate, and space for priority

  This will be shown to the customer. This section should not contain any information that a customer should not see.

  2. General Process

  Details of the overall process and procedure that created the Estimates

  This will be shown to the customer, so only data on the User Story cards from section 1 should be shown.

  3. Background Data

  Details on spread, assumptions, issues, etc.

  How did the team interaction work, and what did and did not work well

  This will not be shown to the customer. It is for your supervisor.

  In other words, the report describes all the work and processes followed while creating the user stories and their estimates. The details of the general process and the general observations in Section 3 are in the form of a narrative, i.e., describe what you did, how you did it, and the result, ordered by time. The report's tone is professional, with a clear, consistent presentation.

  The team created the User Stories and Estimates, but this report is an individual project. In your account, make changes to User Stories if they do not follow the guidelines given in the book. These changes are especially crucial for the Title and the Description. Split User Stories if the Estimate is too large. Explain any changes in your report.

  Content Notes

  • Identify yourself clearly at the top of the page with your name, email, team name, and section
  • Do not address me at the top of the page
  • Do not sign it at the bottom

  Format

  The report uses plain-text formatting syntax Markdown. Markdown is an almost universal format for text formatting in software development. Due to its direct conversion to HTML, Markdown has replaced HTML and other plain-text formatting languages in SE. It has become so popular that it is a new document type in OneDrive.

  • While Markdown does allow using HTML, do not use any HTML in this report
  • The entire report must be in a single, self-contained file: Requirements.md
  • The report is to look good both as raw Markdown and as a web page in GitHub
  • Plain text (no .pdf, .doc, .docx, etc.)
  • UTF–8 encoding, Note: An ASCII document is a UTF–8 document
  • The file, like all text and source-code files, should end in a newline
  • Do not use any unnecessary multiple-blank lines

  Creating the Report

  You will use git to work on your report. Assuming a username of jdoe@uakron.edu, the steps are as follows:

  1. Create your project repository using the link in Brightspace
  2. Copy the URL from your project page
  3. Clone your repository, e.g., jdoe@uakron.edu
  4. Move to your repository directory:
  5. Edit your document. Any text editor will do. E.g., add the title.
  6. Commit your change with a reason for your change: Commit messages start with a verb, e.g., Add, Remove, Change, Fix, Reformat, etc. Follow the style given in this example: Capitalized verb, no period.
  7. View your current commits:
  8. Push your commits to GitHub:
  9. Verify that your changes appear in GitHub
  10. Repeat steps 5-9 for each change.

  Note: All commits must have non-blank commit messages. Any non-blank commit messages will not be accepted, leading to a 0 on the entire project.

  GitHub Codespace

  A GitHub Codespace is available for this project. See the guide GitHub Codespaces.

  Final Check

  After you have committed your final change to the project, you must run your report through a report check to see if it follows many of the Markdown requirements of the project. To do so, create a GitHub Codespace for the project. When in there, enter the command:

  You should see a clean report. If it finds anything, fix it and rerun the checkmd command.

  The checkmd is a custom command created for this project to verify specific Markdown requirements. A clean run does not mean you have nothing wrong with your project.

  Final Submission Requirement

  Upload an terminal session of your report successfully passing the checkmd program.

  To demonstrate this, you will record a terminal session using asciinema. It records the commands you enter and the output the command produces. asciinema is already installed in the GitHub Codespaces image. You can also install asciinema on Linux/WSL/macOS.

  asciinema is relatively straightforward to use.

  Further Note I am removing the screencast requirement for Project 1

  Note I removed the example screencast because it is for an old version of asciinema. Go to the asciinema site, or wait until Tuesday, Sep 22 when I will demonstrate it in class. The screencast URL due date is extended to 11:59:59 pm on Tuesday, Sep 22. The project due date remains the same.

  You can play, pause, skip, etc. You can also copy the commands as text. Note that the replay even includes your pauses and any delay as the command is run.

  At the end of the terminal session, asciinema will show a URL. Anybody can use this URL to view the session. This is what you will submit for the exercise to the link in the exercise title. The URL should not contain "connect" or be a local file. Test your URL in a browser; an incorrect URL will receive a 0.

  Submit the URL via this form: Project 1

  Score

  The report content, format, and involvement in team activities are all considered for your score.

  Think carefully about how you present the report, including using Markdown. Remember, the User Stories form an unordered set, not an ordered list.

• Exercise 12: Team User Story Estimates Posted: Sep 10

  Start by reviewing your user stories, particularly the titles. Titles that do not have an action term, or have a poor action term, will be counted off on your score for this exercise.

  As a team, create estimates for the user stories by using the planning poker procedure described on pages 48-49 of the book.

  When the team reaches a consensus for the estimate, place the estimate at the bottom left of the User Story as indicated by the example, e.g., "Estimate: 1 day" or "Estimate: 3 days".

  Individually, each team member will turn in to Brightspace individual notes that include for each round of planning poker:

  • Title of the user story
  • Any questions on or confusions with the user story
  • Any assumptions that you made
  • Any interesting assumptions that other team members made
  • The spread of estimates, indicating which one is yours. Be very careful with this, and note that a spread is on a number line.
  • The estimate, which is a team consensus (if the team was able to reach one in this round)

  If the team is not able to come to a consensus, table that User Story and go on to another one.

  The notes are due by the end of class. They can be in the form of a PDF (print to file from a computing device), or a JPG (picture taken via your phone).

  The more you work with the user stories, the more you will find improvements to them. Be sure to make those improvements. Also, you may think of additional user stories. Be sure to add them.

• Week 3 Class 5 Tue Sep 08 Posted: Sep 08

  After Class

  • Exercise 11: GitHub Username GitHub Classroom is no more. Instead, we are using Classroom 50. The process for allowing you to create a repository has changed and is as follows: 1) Add you to the UACPSC GitHub Organization, and 2) Add you to the roster for the course. To do so, I need your GitHub Username. If you don't provide it, you won't be able to do the projects and some exercises.

    The title of this exercise is a link to the form where you can enter your GitHub Username.

    I am posting this early since the deadline is earlier than normal. Due Friday, Sep 11 by 9 am.

  Announcements:

  • Team Exercises & Feedback Each team member gets individual feedback on the team exercises. This includes the work the team did as a whole, as well as your individual contributions. Feedback from the previous team exercise often relates to the current team exercise. Therefore, I am requiring you to view your feedback from the last team exercise via the Assignments page. Failure to do so will result in a large penalty to your exercise score. I suggest that the team remind each other about this at the start of the team meeting.
  • Guide: User Story Title Candidates Feedback

  • Action-Oriented Titles

    The primary goal of user stories is to capture a specific need or goal of a user in the context of software development. It's about "what the user wants to do" or "achieve" with the software.

    Benefits of Action-Oriented Titles:

    • Clarity Action-oriented titles make it clear what the expected outcome or behavior of the system should be
    • Focus on Value Emphasizing actions reminds the team to focus on delivering value and functionality rather than just creating artifacts
    • Facilitates Testing It is easier to derive test cases from action-oriented stories

  • User Story Titles and the Number Grammatical Category

    Strongly consider using a title with a singular noun for a user story, instead of a title with a plural noun, because it emphasizes the atomic nature of the action.

    Plural	Singular
    Upload Documents	Upload a Document
    Send Messages	Send a Message
    Add Products to Cart	Add a Product to the Cart
    Register for Events	Register for an Event
    View Notifications	View a Notification
    Search for Jobs	Search for a Job

    In general, user stories with singular titles are going to be easier to implement. There can be exceptions, as "View Notifications" may be simpler than "View a Notification" due to not having to select just one.

    The most important aspect is clarity and understanding. If "Purchase Clothes" effectively communicates the intent without ambiguity and your team finds it more natural, it's also acceptable. The choice between singular and plural should ultimately be guided by what best serves the clarity and focus of the story in your context.

  • Development Environment: Git Setup by next class.

  Class

  • HFSD Chapter 2
  • Exercise 9: HFSD Chapter 2 Crossword
  • HFSD Chapter 3
  • Exercise 10: Team User Stories II

  Unless stated otherwise, all exercises are due by 4 pm on Wed Sep 09

• Exercise 10: Team User Stories II Posted: Sep 08

  

  Your team is to correct the current user stories and increase the number of user stories. Very carefully go over your user titles and descriptions. Add more user stories and see what you are missing.

  The number of user stories per teams was 7, 9, 11, 12, 16, 16, 16, 17, and 27(!). Twelve and under are far too few. Greatly increase the number.

  Remember to split any user stories that you can. Apply the "and" rule.

  • I want a lot of user stories. Do not make any judgments on whether they are worthwhile or not. Generate as many as you can
  • The User Stories do not belong to an individual team member. They belong to the team. So feel free to make changes to stories, even if you are not the original author.
  • For this assignment, no User Story should have a title that includes "Login" or similar terms. Assume that they have already logged in or (much better) do not have to log in.
  • You have not performed an estimation process. Do not fill in the estimate with some guess or random number.

  In addition to the team work of extracting user stories from the app description, each team member will turn in to Brightspace individual notes that includes:

  • The total number of user stories
  • The titles of at least five user stories. Just state them. No order required.

  The individual notes are due by the end of class uploaded to Brightspace. They can be in the form of a PDF (print to file from a computing device), or a JPG (picture taken via your phone).

  Do not upload a photo of all your user stories This will result in a very low score for the exercise. Follow the directions for the individual notes.

• Week 2 Class 4 Thu Sep 03 Posted: Sep 03

  Announcements:

  • Exercise 3: App Idea The feedback on Tuesday for this exercise included "If you fail to fix your issues or view your feedback by 3 pm on Wed Sep 02 I will change your score to a 0". Viewing feedback on an assignment is part of the exercise and project process. If you did not fix your issues or view the feedback, I changed your score to a 0.
  • Data Format Example ADA Title II → WCAG 2.1 AA (or better)

  Class

  • HFSD Chapter 2

  • Exercise 7: HFSD Chapter 2 p42 User Story Interview

    • Be sure to save your response
    • You cannot go back and edit your response
    • The number correct is your score out of 10

  • Exercise 8: Team User Stories

    • Note that almost all Team Exercises will have individual notes due by the end of class.

  Unless stated otherwise, all exercises are due by 4 pm on Fri Sep 04

• Exercise 8: Team User Stories Posted: Sep 03

  

  Each Team is assigned a separate App with the description in Brightspace.

  As a Team, create as many User Stories as you can for that app from the app description. For now, this is just the Title and the Description. The Title is just an action that a user can perform. The Description is from 1 to 3 sentences that describes what that action is. Follow the examples given in the book.

  The User Stories are written on the provided index cards. I will provide a folder for you to put the cards in as I will collect the cards at the end of class.

  • I want a lot of user stories. Do not make any judgments on whether they are worthwhile or not. Do not stop at 6 or some specific number. Generate as many unique user stories as you can.
  • You do not "own" a user story. The user story is part of the project. If you leave the project, the user stories do not go with you.
  • For any assignment in this class, no user story should have a title that includes "Login" or any similar terms. Assume that they have already logged in or (much better) do not have to log in.

  In addition to the team work of extracting user stories from the app description, each team member will turn in to Brightspace separate, individual notes that include:

  • The total number of user stories created
  • The titles of at least 3 user stories

  The individual notes are due by the end of class uploaded to Brightspace. They can be in the form of a PDF (print to file from a computing device), or a JPG (picture taken via your phone).

• Week 2 Class 3 Tue Sep 01 Posted: Sep 01

  Announcements:

  • Exercise 3: App Idea I posted scores and feedback in Brightspace

    • "Do not identify yourself in the description"
    • "Submit via Brightspace in PDF form" Word documents are not PDFs

    View your feedback even if you got a 10 / 10. In some cases, a 10/10 does not mean there was nothing wrong.

    Fix any issues that I identified.

    If you fail to fix your issues or view your feedback by 4 pm on Wed Sep 02 I will change your score to a 0

    Note: This "fix your issues and get full points" is not the norm for the exercises and assignments in the course

  Class

  • HFSD Chapter 1

  • Exercise 5: HFSD Chapter 1 Crossword

    • Print using browser (not a screenshot). If a screenshot or a scan, you will receive a 0.
    • Include a timestamp with Headers and Footers (Chrome: More settings/Options; Safari: Safari/Print headers and footers)
  • HFSD Chapter 2
  • Exercise 6: Teams

  Unless stated otherwise, all exercises are due by 4 pm on Wed Sep 02

• Exercise 6: Teams Posted: Sep 01

  Form a team of 4 members. The final team composition is at the discretion of the instructor.

  After forming a team, your team needs to decide on a name from the following choices:

  • Three Stooges (Moe, Larry, Curly, Shemp, Curly Joe)
  • Marx Brothers (Chico, Harpo, Groucho, Gummo, Zeppo)
  • Star Wars Characters

  Pick at least 4 names.

  Send Dr. Collard and Mr. Cowan an email with the following:

  • Subject is CPSC480-020 Team
  • CC all members of the team using their UA email address
  • An attachment file, members.csv, in the CSV (Comma-Separated Values) format. Use the following as an example:

  
  Firstname,Lastname,Email,Section,Team
  John,Doe,johndoe@uakron.edu,020,Harpo
  Jane,Doe,janedoe@uakron.edu,020,Harpo
  Brian,Doe,briandoe@uakron.edu,020,Harpo
  Suzy,Doe,suzydoe@uakron.edu,020,Harpo
  
  

  • The body of the email is a list of requested team names in priority order, e.g.,

  
  Harpo
  Moe
  Yoda
  Zeppo
  
  

  The purpose of a team is not just to divide the work but also to meet a required level of quality. All members of the team must check any team assignment in this course. You, as a team, are responsible for these directions. Any emails sent as part of an assignment (including exercises) must have the correct subject, CC list, and contents. Exercises are not accepted and do not receive points if they do not have the proper form and content.

  The exercise is due by the end of class.

• Week 1 Class 2 Thu Aug 27 Posted: Aug 27

  Announcements:

  • Notes The links to the Notes page and the Context notes are fixed.
  • Scores I posted the feedback and scores in Brightspace for Exercises 1 & 2

  • Syllabus Missed section on prerequisites.

    Prerequisites: Minimum C- in CPSC 210 Computer Science II

    Since the prerequisite course is in C++, we will also use C++.

  • Survey Results
  • Notes The class notes have a bunch of default and custom hotkeys. Type a "?" to see the help.

  Class

  • Notes: Context

  • Exercise 3: App Idea - Submit via Brightspace in PDF. Due by 4 pm on Mon Aug 31

    All applications start with an idea or a need. As a user, write a description of an application. The description should include who would use it and its features. The application can be one that you create yourself or an existing program.

    Guidelines:

    • The description must be at least 350 words long
    • Include a name for the app at the top
    • Do not identify yourself in the description
    • Assume this is a smartphone app
    • The description should be of the what not the how. Do not include any discussion of programming languages, libraries to use, or software design. Do not talk about how easy or difficult it would be to create the app. Do not describe the screens, views, or user interaction.
    • If the application already exists, be creative with your name and description

    Comments:

    • This is not the place if you have a great app idea. Your app idea may be shared with others or discussed (anonymously) with the entire class.
    • This is not the app that you or your future team will work on.
  • Notes: Roots
  • HFSD: Chapter 1
  • Exercise 4: HFSD Chapter 1 Sharpen Your Pencil Completed during class.

  Unless stated otherwise, all exercises are due by 4 pm on Fri Aug 28

• Week 1 Class 1 Tue Aug 25 Posted: Aug 25

  After Class

  • The links to the Notes page and the Context notes are fixed.

  Announcements

  • Syllabus The syllabus is available via a link on the main page. It is via Simple Syllabus and you must be logged into UA to view the full contents. The course description does not reflect the last changes, and should be:

  A comprehensive overview of all phases of software development, including requirements, analysis, design, implementation, testing and validation, release, maintenance, and evolution, focusing on agile methodologies.

  • GitHub We use GitHub and GitHub Classroom in the class to manage documents and source code for projects, exercises, and examples. You are required to have a GitHub account. Optionally, you can apply for the Student Github Developer Pack and get a free GitHub Pro account. To apply, your account email can be a school account or a personal account if you upload documents to prove your current enrollment status.
  • O'Reilly Online Learning The course textbooks are available in O'Reilly Online Learning. You do not have to be on the campus network (e.g., via VPN) to access O'Reilly Online Learning. To access, click the "Institution not listed?" link below the dropdown and enter your UA email. You will then create an account and use that account from now on. For more information: Library LibGuide

  Exercises

  • Exercise 1: SE Survey

  • Exercise 2: Software Development Diagram

    Draw the Software Development Diagram that I present in class. Upload a PDF or JPG through Brightspace.

  • Notes: Context

  • For next class: Read Chapter 1 of the HFSD (Head First Software Development) book.

  All exercises are due by 4 pm on Wed Aug 26

• Welcome Posted: Aug 21

  Greetings and welcome to CPSC 480 Software Engineering (SE) section 020 for Fall 2026.

  • Survey The first exercise is to fill out the class survey. The survey is due after our first class meeting, but you can complete it before.
  • Syllabus The syllabus is available via a link on the main page. It is via Simple Syllabus and you must be logged into UA to view the full contents. The course description does not reflect the last changes, and should be A comprehensive overview of all phases of software development, including requirements, analysis, design, implementation, testing and validation, release, maintenance, and evolution, focusing on agile methodologies.
  • Textbook The course has two textbooks. We start with the Head First Software Development (HFSD), available from Safari Books Online via a link at the bottom of the main course page.
  • GitHub In the class, we use GitHub and a GitHub Organization to manage documents and source code for projects and examples. You are required to have a GitHub account. The account email (not necessarily the account name) should be your @uakron.edu email address. If it is, you can apply for the Student Github Developer Pack and get a free GitHub Pro account.

  See you on Tuesday, Aug 25 at 3:30 - 4:45 pm in Arts & Sciences (CAS) room 134