README-en.md edited on August 3, 2016 at 10:30am

README-en.md

 
 [Verano 2016 - Ive - Coralys]
 
-In almost every instance in which we want to solve a problem, we select among are one or more options that depend on whether certain conditions are met. Computer programs are built to solve problems, therefore they should have a structure that allows them to make decisions and select alternatives. In C++, selections are structured using `if`, `else`, `else if` or `switch`. Relational expressions and logical operators are common when handling selection structures. In this laboratory experience you will practice the use of some of these selection structures by completing the design of an application that determines the strength of a password.
+In almost every instance in which we want to solve a problem, we choose among are one or more options that depend on whether certain conditions are met. Computer programs are built to solve problems, therefore they should have a structure that allows them to make decisions and select alternatives. In C++, selections are structured using `if`, `else`, `else if` or `switch`. Relational expressions and logical operators are common when handling selection structures. In this laboratory experience, you will practice the use of some of these selection structures by completing the design of an application that determines the strength of a password.
 
 ## Objectives:
 
 
 1. Reviewed the following concepts:
 
-    a. Logical operators.
+    a. logical operators.
 
     b. `if`, `else`, `else if`.
 
 
 ---
 
-## Password strength
+## Password Strength
 
-Using strong passwords is essential to securing information. A password is considered strong if it is not cost-effective for a hacker to try and guess it using different methods or brute force. For example, a password that consists of a simple dictionary word, without digits, symbols or uppercase letters, is so easy to decipher that even a caveman could do it.
+Using strong passwords is essential to securing information. A password is considered strong if it is not cost-effective for a hacker to try and guess it using multiple methods or brute force. For example, a password that consists of a simple dictionary word, without digits, symbols or uppercase letters, is so easy to decipher that even a caveman could do it.
 
 Since an official system to measure password strength doesn't exist, we will use formulas created by the passwordmeter to evaluate the general strength of a given password [1]. We recommend that you play around a bit with the application in http://passwordmeter.com so that you understand how the application you will be implementing should behave. The strength of the password will be quantified by adding points for using good techniques of password selection (like using symbols and letters), and subtracting points for using bad habits (like only using lowercase letters or consecutive symbols of the same type).
 
 The following tables review the added and subtracted values for various criteria in passwords.
 
 
-### Assigning points to a password
+### Assigning Points to a Password
 
 #### Adding Points:
 
 
     a. The score for `"ab453"` would be $$0$$ because it does not contain symbols.
 
-    b. The score for `"ALGO!!"` would be $$6 \cdot 2$$ because it contains $$2$$ symbols and contains other types of characters.
+    b. The score for `"ALGO!!"` would be $$6 \cdot 2 = 12$$ because it contains $$2$$ symbols and contains other types of characters.
 
     c. The score for `"---><&&"` would be $$6 \cdot 7 = 42$$ because it contains $$7$$ symbols. Note that in the case of symbols, points are given even when there aren't other types of characters.
 
 
     c. The score for `S&c8i7o!` would be $$2 \cdot 3 = 6$$ because it has $$3$$ symbols or digits in the middle, these are `&`, 8`, and `7`.
 
-7. **Requisites:** The score is $$2n$$ only if the length criteria **and** 3 or 4 of the other criteria are met, where $$n$$ is the number of *criteria* that are met. The criteria are:
+7. **Requisites:** The score is $$2n$$ only if the length criteria **and** 3 or 4 of the other criteria are met, where $$n$$ is the number of *criteria* that is met. The criteria are:
 
     a. The password must have 8 or more characters of length.
 
        iii. The score for `"abAB99!!"` would be $$2 \cdot 5 = 10$$ because the length criteria and the other 4 criteria are met.
 
 
-#### Subtracting points
+#### Subtracting Points
 
 ---
 
 
 The following are additional details and examples of the criteria for **subtracting points**.
 
-1. **Letters only:** The score is $$-len$$ for a password that consists of letters only, otherwise it is $$0$$. For example:
+1. **Letters only:** the score is $$-len$$ for a password that consists of letters only, otherwise it is $$0$$. For example:
 
       a. The score for `"ab453"` would be $$0$$ since it contains letters and numbers.
 
       b. The score for `"Barrunto"` would be $$-8$$ since it only contains letters and its length is $$8$$.
 
-2. **Digits only:** The score is $$-len$$ for a password that consists of digits only, otherwise it is $$0$$. For example:
+2. **Digits only:** the score is $$-len$$ for a password that consists of digits only, otherwise it is $$0$$. For example:
 
       a. The score for `"ab453"` would be $$0$$ since it contains only letters and numbers.
 
-      b. The score for `"987987987”` would be $$-9$$ since it contains only digits and its length is $$9$$.
+      b. The score for `"987987987"` would be $$-9$$ since it contains only digits and its length is $$9$$.
 
-3. **Consecutive uppercase letters:** The score is $$-2n$$ where $$n$$ is the number of uppercase letters that follow another uppercase letter. For example,
+3. **Consecutive uppercase letters:** the score is $$-2n$$ where $$n$$ is the number of uppercase letters that follow another uppercase letter. For example,
 
       a. the score for `"DB453"` would be $$-2 \cdot 1 = -2$$ since it only contains one uppercase letter (`B`) that follows another uppercase letter.
 
       b. the score for `"TNS1PBMA"` would be $$-2 \cdot 5 = -10$$ since it contains 5 uppercase letters (`N`, `S`, `B`, `M`, `A`) that follow another uppercase letter.
 
-4. **Consecutive lowercase letters:** The same as for criteria #3, but for lowercase letters.
+4. **Consecutive lowercase letters:** the same as for criteria #3, but for lowercase letters.
 
-5. **Consecutive digits:** The same as for criteria #3, but for digits.
+5. **Consecutive digits:** the same as for criteria #3, but for digits.
 
 
 ---
 
 ---
 
-## Laboratory session:
+## Laboratory Session:
 
 In this laboratory experience you will practice the use of mathematical expressions and selection structures to compute the score for the strength of a password combining the points for the individual criteria.
 
 
 
 
-### Exercise 1 - Familiarize yourself with the pre-defined functions
+### Exercise 1 - Familiarize Yourself with the Pre-defined Functions
 
 The first step in this laboratory experience is to familiarize yourself with the functions that are pre-defined in the code.  You will call these functions as part of your own code to compute the score of the various password strength criteria.
 
-#### Instructions:
+#### Instructions
 
 1. Load the project  `PassworStrength` into `QtCreator`. There are two ways to do this:
 
   * `psfunctions.h` : contains the prototypes for the functions defined in `psfunctions.cpp`.
 
 
-### Exercise 2 - Understand the functions to update the user's graphical interface.
+### Exercise 2 - Understand the Functions to Update the User's Graphical Interface.
 
 In the laboratory exercise you will write code to calculate the score associated to each one of the criteria in the tables for adding and subtracting points shown above. These scores should be updated in the user's graphical interface that is shown in Figure 1.
 
 ```
 
 
-### Exercise 3 - Compute the score for the criteria and the total score for the password
+### Exercise 3 - Compute the Score for the Criteria and the Total Score for the Password
 
 The code that we're providing you contains the functions that compute the count for the majority of the criteria and whose names reflect what they do and what the function returns. For example, `countUppercase`, return the number of characters that are uppercase letters.
 
 In the project's code you will find examples of how to calculate the first two positive criteria: the number of characters in the password and the numbers of uppercase letters. You can compile and execute the example so you can see the working interface with these two criteria. Part of your task is to add the code to compute the score for the remaining criteria. Remember that you should accumulate the total score and invoke the functions to update the graphical interface.
 
 
-### Exercise 4 - Determine and display the password's strength
+### Exercise 4 - Determine and Display the Password's Strength
 
 The user will input the password in the top section of the graphical interface. Below appears the *report* that contains the different criteria, the count for each criteria, and the individual score for the criteria. This report will be updated as the user inputs the password's characters. The total score will be the sum of all of the points (addition and subtraction) of the individual criteria.
 
 
 ## Deliverables
 
-Use "Deliverable" in Moodle to upload the `readpassword.cpp` file that contains the code with the computation for the score of the individual criteria, the final score, the function calls to update the graphical interface, the password's classification and the display functions. Remember to use good programming techniques, by including the name of the programmers involved, and documenting your program.
+Use "Deliverable" in Moodle to upload the `readpassword.cpp` file that contains the code with the computation for the score of the individual criteria, the final score, the function calls to update the graphical interface, the password's classification and the displayed functions. Remember to use good programming techniques, include the name of the programmers involved, and document your program.