Meeting 06: Module and API Design

The goal of today's meeting is to understand what makes a program or library well designed. These are somewhat subjective criteria but constitute the consensus of a large number of good programmers. You should strive to follow these principles and recommendations.

• DRY Principle
• Single-Responsibility Principle
• Othogonality
• Coupling and Law of Demeter
• Principle of Least-Astonishment
• Naming and Arguments

Links:

• Slides

Exercise 06: Designing an Argument Class

Command-line applications often allow user input at program startup, using the argument to main:

int main(int argc, char *argv[])

where argc is the number of space-separated strings type after the executable name. For example, suppose we have an executable named do.exe. It might take several different arguments (> is the command prompt)

> do.exe -flag -setting=12 afilename1 afilename2

where

• flag is an option, if argv[1]="-flag" is present the flag it considered set by the program, else not
• setting is a parameter with the text after the = parsed as a number
• afilename1 and afilename2 are just strings representing filenames

The first two arguments are optional and by convention start with a dash. Their ordering on the command-line does not matter. The last two are called a positional arguments, are required, and their order matters. So the following would start the program the same way:

> do.exe -setting=12 afilename1 -flag afilename2

Generally if a required argument is missing or an unexpected argument is present then an error is printed along with usage information, e.g.

> do.exe -flag myfile.txt
Error: missing positional argument

Usage: do.exe [-flag] [-setting=N] file1 file 2

* flag is an optional flag
* setting is an optional parameter where N is a positive integer
* file1 is the input file
* file2 is the output file

Consider a class named CommandLineArguments that helps the programmer deal with command-line arguments. Design a class to do this by creating a header file command_line_arguments.hpp that defines the public part of the class interface.

• What member functions should it have?
• What should they be named?
• What arguments should they take?
• What should they return?
• What should the comments say they do?

You do not have to implement any of the methods and you can create other abstractions (classes, functions) as needed without explicitly defining them.

This code does not have to compile.

GitHub Invitation URL: exercise6

Steps:

1. Create a working directory somewhere on your computer, then change to that directory.

2. Clone the assignment for today after accepting the GitHub invitation at the link above.

   git clone https://github.com/VTECE3574/exercise06-USER.git

   where USER is your GitHub username. You may have to enter your GitHub username and password.

3. In the file named command_line_arguments.hpp design your class as instructed above.

4. Now, use git to commit your changes to the local repository.

5. Finally, use git push to synchronize the repository with that on GitHub

You have completed the Exercise.