• String manipulation: Extracting and analyzing characters from user input.
• Loops: Iterating over digits to process each one individually.
• Accumulator variables: Keeping a running total (like a weighted sum).
• Conditional logic: Making decisions based on checksum values or input validity.
• Type conversion: Switching between strings and numbers to perform calculations.

Because these algorithms are short and precise, they’re perfect for building confidence while teaching students how computers validate data efficiently — a foundational concept in software engineering, data processing, and cybersecurity. Plus, the immediate feedback from correct or incorrect results makes debugging intuitive and satisfying.

Check Digits

A check digit is a single digit number added to the end of a longer number, used to verify the accuracy of this number. It’s calculated using a specific algorithm based on the other digits in the number and helps detect errors when the number is entered manually or transmitted electronically.

In this document, I present the following check digits and the algorithms to compute them:

1. IBSN-10 and ISBN-13 (International)
2. Identity Card Number (China)
3. UPC-A Barcodes (International)
4. Credit Cards Check Digit (International)
5. International Securities Identification Number (International)
6. Shipping Container Identification Number (International)
7. IBAN (International)
8. VIN (International)
9. CLABE (Mexico)
10. GSTIN (India)
11. Fødselsnummer (Norway)
12. Sozialversicherungsnummer (Germany)
13. CURP (Mexico)
14. Número de la Seguridad Social (Spain)
15. CAS Registry Number (CAS RN)
16. Turkish Identification Number (Turkey)
17. South African ID Number (South Africa)
18. EAN-8 Barcode

1. International standard book number (IBSN)

An ISBN (International Standard Book Number) is a unique identifier assigned to commercial books. Before 2007, ISBNs were 10 digits long. After that year, they were expanded to 13 digits to align with international EAN standards.

In both ISBN-10 and ISBN-13 formats, the last digit is a check digit, used to detect errors in the number.

• In ISBN-10, the check digit can be a number from 0 to 9 or the letter ‘X’, which represents the value 10.
• In ISBN-13, the check digit is always a digit from 0 to 9.

The purpose of this task is to write a program that checks whether a number is a valid ISBN-10 or a valid ISBN-13.

ISBN-10 Check Digit Calculation

• Calculate s, the weighted sum of the first 9 digits, using decreasing weights from 10 to 2.
• Compute n, the number that must be added to s to make it divisible by 11:

n = (11 - (s % 11)) % 11

• If n == 10, the check digit is 'X'. Otherwise, it is the digit n.

ISBN-13 Check Digit Calculation

• Calculate s, the weighted sum of the first 12 digits, using alternating weights of 1 and 3, starting with 1 on the left.
• Compute n, the number that must be added to s to make it divisible by 10:

n = (10 - (s % 10)) % 10

• The check digit is n.

Example ISBN-10: 0306406152

• Weighted sum:

0×10 + 3×9 + 0×8 + 6×7 + 4×6 + 0×5 + 6×4 + 1×3 + 5×2 = 130

• Check digit:

(130 + 2) % 11 = 0

0306406152 is a valid ISBN-10.

Example ISBN-13: 9780306406157

• Weighted sum:

9×1 + 7×3 + 8×1 + 0×3 + 3×1 + 0×3 + 6×1 + 4×3 + 0×1 + 6×3 + 1×1 + 5×3 = 93

• Check digit:

(93 + 7) % 10 = 0

9780306406157 is a valid ISBN-13.

Program Requirements

• Prompt the user with:
  "Enter an ISBN number: "
• Check the length of the input:
  - If it’s neither 10 nor 13 characters, print:
  "Not a valid ISBN."
• If the input has 10 (or 13) digits:
  - Compute the ISBN-10 (resp. the ISBN-13) check digit based on the first 9 digits (resp. the 12 digits).
  - Compare it to the last digit.
  * If it matches: print "Valid ISBN-10"
  * If not: print "Not a valid ISBN-10"

Sample output

>>> Enter an ISBN number: 020151141
>>> Not a valid ISBN

>>> Enter an ISBN number: 020151141X
>>> Valid ISBN-10

>>> Enter an ISBN number: 0306406153
>>> Not a valid ISBN-10

>>> Enter an ISBN number: 0306406152
>>> Valid ISBN-10

>>> Enter an ISBN number: 9782340076556
>>> Valid ISBN-13

2. Identity Card Number

The Identity Card Number (ICN) is an 18-digit number that uniquely identifies every citizen in mainland China. The last digit is called the checksum, which is used to confirm the validity of the first 17 digits.
The checksum can be a digit from 0 to 9, or the letter ‘X’ if its value is 10.

The goal of this task is to write a program that checks whether a given number is a valid Identity Card Number.

Checksum Calculation

1/ Index the digits from right to left, starting from 1.

That is, the rightmost digit (checksum) has index 1, the second-to-last has index 2, and so on up to index 18 on the leftmost digit.

2/ Compute the weighted sum of the first 17 digits, using the following formula for the weight of each digit:

W_i = 2^{i−1} mod 11

where i is the index from the right (i.e., the leftmost digit has i =18, the rightmost of the 17 digits has i = 2).

Example: 911124198108030024

1/ For the number 911124198108030024, the weights from left to right (i = 18 to 2) are:

W_18 = 2^17 % 11 = 131072 % 11 = 7
W_17 = 2^16 % 11 = 65536 % 11 = 9
W_16 = 2^15 % 11 = 32768 % 11 = 10
...

2/ The weighted sum is:

= 9 × 7 + 1 × 9 + 1 × 10 + 1 × 5 + 2 × 8 + 4 × 4 + 1 × 2 + 9 × 1 + 
  8 × 6 +1 × 3 + 0 × 7 + 8 × 9 + 0 × 10 + 3 × 5 + 0 × 8 + 0 × 4 + 2 × 2  
= 272

3/ The checksum is:

M = (12 − (272 mod 11)) mod 11 = 4

4/ 911124198108030024 is a valid Identity Card Number.

Program Requirements

• Prompt the user with:
  "Enter an Identity Card Number: "
• If the input is not 18 characters long, print:
  "Not a valid Identity Card Number."
• If the first 17 characters are not all digits, or the last character is neither a digit nor ‘X’, print:
  "Not a valid Identity Card Number."
• If the input passes the format check:
  - Compute the checksum from the first 17 digits.
  - Compare it to the last digit:
  * If they match: print "Valid Identity Card Number."
  * If they don’t match: print "Not a valid Identity Card Number.

Sample Output

>>> Enter a Identity Card Number: 91112419810803002
    Not a valid Identity Card Number.
>>> Enter a Identity Card Number: 911124198108030021
    Not a valid Identity Card Number.
>>> Enter a Identity Card Number: 91112419810803002X
    Not a valid Identity Card Number.
>>> Enter a Identity Card Number: 911124198108030024
    Valid Identity Card Number.
>>> Enter a Identity Card Number: 22010219900307257X
    Valid Identity Card Number.

3. UPC-A Barcodes

A barcode is a method of representing data in a visual, machine-readable form. Linear barcodes encode information by varying the widths, spacings, and sizes of parallel lines.

Different types of linear barcodes encode different numbers of digits. In this task, we focus specifically on UPC-A barcodes.

In linear barcodes, the last digit is called the check digit, which is used to verify that the barcode has been scanned correctly.

The image below shows a UPC-A barcode, where the rightmost digit (2) is the check digit.

The goal of this taks is to write a Python program that computes and verifies the check digit for a UPC-A barcode.

What is a UPC-A Barcode?

A UPC-A barcode encodes exactly 12 digits:

• The first 11 digits are data digits.
• The last digit is the check digit, used to verify the integrity of the first 11 digits.

The check digit is an integer from 0 to 9.

UPC-A Check Digit Calculation

1. Start with the first 11 digits of the barcode (exclude the last digit).
2. Multiply the digits in odd positions (1st, 3rd, 5th, etc.) by 1.
3. Multiply the digits in even positions (2nd, 4th, 6th, etc.) by 3.
4. Sum the results of both groups.
5. Compute the result modulo 10:

• If the sum is divisible by 10, the check digit is 0.
• Otherwise, subtract the last digit of the sum from 10 to get the check digit.

Example: 036000291452

UPC-A barcode: 036000291452(The last digit, 2, is the check digit.)

• First 11 digits: 03600029145
• Even-positioned digits (1 × weight):

3 + 0 + 0 + 9 + 4 = 16

• Odd-positioned digits (1 × weight):

(0×3) + (6×3) + (0×3) + (2×3) + (1×3) + (5×3) = 42

• Total sum:

16 + 42 = 58

• Modulo 10:

58 % 10 = 8

• Check digit

10 – 8 = 2

• 036000291452 is a valid UPC-A barcode.

Program Requirements

• Prompt the user with:
  "Enter a UPC-A barcode: "
• Check if the input is exactly 12 digits:
  - If not, print: "Not a valid UPC-A barcode."
• Compute the checksum using the first 11 digits.
• Compare the computed check digit with the last digit entered:
  - If they match, print: "Valid UPC-A barcode."f
  - If not, print: "Not a valid UPC-A barcode."

Sample Output

>>> Enter a UPC-A barcode: 03600029145
    Not a valid UPC-A barcode
>>> Enter a UPC-A barcode: 03600029145X
    Not a valid UPC-A barcode
>>> Enter a UPC-A barcode: 036000291457
    Not a valid UPC-A barcode
>>> Enter a UPC-A barcode: 036000291452
    Valid UPC-A barcode

4. International Securities Identification Number

An International Securities Identification Number (ISIN) is a globally standardized code used to uniquely identify a security (such as a stock or bond) for clearing, reporting, and settlement of trades.

An ISIN is a 12-character alphanumeric code, structured as follows:

• The first two characters are letters, identifying the issuing country (e.g., “US” for the United States).
• The next nine characters are alphanumeric, representing the security identifier.
• The last character is a numeric check digit, used to verify the validity of the ISIN.

The goal is to write a program that checks whether a given 12-character string is a valid ISIN based on the check digit algorithm.

ISIN Check Digit Calculation

1. Convert any letters to numbers by taking the ASCII code of the capital letter and subtracting 55.
2. Drop the check digit to form the payload.
3. With the payload, start from the rightmost character. Moving left, double the value of every second digit.
4. Sum the values of the resulting digits.
5. Take the modulo 10 of the sum.
6. Subtract from 10.
7. Take the modulo 10 of the result.

Example: US0378331005

• Letters: U = 85 - 55 → 30, S = 83 - 55 → 28
• Expanded digits:
  US037833100 → 3028037833100
• Double the value of every second digit:

(3×2)+0+(2×2)+8+(0×2)+3+(7×2)+8+(3×2)+3+(1×2)+0+(0×2)

• The sum of the resulting digits is:

6 + 0 + 4 + 8 + 0 + 3 + (1 + 4) + 8 + 6 + 3 + 2 + 0 + 0 = 45

• The check digit is:

(10 - (45 mod 10)) mod 10 = 5

Program Requirements

• Prompt the user:
  "Enter an ISIN number: "
• Validate input length:
  - If the input is not exactly 12 characters, print:
  "Not a valid ISIN."
• Validate format:
  - If the first 11 characters contain invalid characters, print:
  "Not a valid ISIN."
• If the format is valid:
  - Compute the check digit using the steps above.
  - Compare it to the last digit of the input:
  * If they match, print: "Valid ISIN."
  * If they don’t match, print: "Not a valid ISIN."

Sample Output

>>> Enter a ISIN number: US0378331005
    US0378331005 is a valid ISIN number
>>> Enter a ISIN number: US0378331006
    US0378331005 is not a valid ISIN number
>>> Enter a ISIN number: US037833100
    US0378331005 is not a valid ISIN number
>>> Enter a ISIN number: AU0000XVGZA3
    AU0000XVGZA3 is a valid ISIN number
>>> Enter a ISIN number: AU0000XVGZAX
    AU0000XVGZAX is not a valid ISIN number

5. Credit Cards Numbers

Credit card numbers are composed of 8 to 19 digits, structured into the following parts:

• The first 6 to 8 digits represent the Issuer Identification Number (IIN), also known as the Bank Identification Number (BIN).
• The digits following the IIN, excluding the last digit, represent the individual account number.
• The last digit is the Luhn check digit, used to validate the entire number.

The Luhn check digit is calculated by the Luhn algorithm as follows:

1. Drop the check digit (if validating an existing number). This leaves the payload.
2. Starting from the rightmost digit of the payload (moving left), double every second digit.
3. If doubling a digit results in a number greater than 9, subtract 9 from it (or equivalently, sum its digits).
4. Add up all the digits, including the ones that were not doubled.
5. Compute the check digit using the formula: (10 — (s mod 10)) mod 10 where s is the sum from step 3.

The goal is to write a program that checks whether a given string is a valid credit card numbers based on the Luhn algorithm.

Example: 17893729974

• Drop the check digit → Payload: 1789372997
• Starting from the right, double every second digit:

(7×2) + 9 + (9×2) + 2 + (7×2) + 3 + (9×2) + 8 + (7×2) + 1 =
14 + 9 + 18 + 2 + 14 + 3 + 18 + 8 + 14 + 1

• Sum digits of numbers greater than 9:

14 + 9 + 18 + 2 + 14 + 3 + 18 + 8 + 14 + 1 →
5 + 9 + 9 + 2 + 5+ 3 + 9 + 8 + 5 + 1

• Sum all digits:

5 + 9 + 9 + 2 + 5 + 3 + 9 + 8 + 5 + 1 = 56

• Check digit:

65 modulo 10 = 5

So, the check digit for this credit card number is 5.

Sample Output

>>> Enter a credit card number: 17893729975
    17893729975 is a not valid credit card number
>>> Enter a credit card number: 17893729974
    17893729974 is a valid credit card number

6. Shipping Container Identification Number

Shipping containers are identified by an 11-character code defined by the ISO 6346 international standard. The structure is as follows:

• 4 letters:
  - Owner Code: 3 letters
  - Equipment Category Identifier: 1 letter
• 6 digits: Serial number
• 1 digit: Check digit

Shipping Container Identification Number Check Digit Calculation

1/ Assign a numeric value to each letter using the following table:

2/ Combine with the digits of the serial number.

3/ Each position gets a weight of 2^n starting from n = 0 on the left.

4/ Sum of products.

5/ Divide the sum by 11 and take the remainder.

The remainder is the check digit.

Example: CSQU3054383

• Assign a numeric value to each letter:

C = 13, S = 30, Q = 28, U = 32
C  →  13
S  →  30
Q  →  28
U  →  32
3  →  3
0  →  0
5  →  5
4  →  4
3  →  3
8  →  8

• Multiply values by weights:

C  (13 × 1)     =   13  
S  (30 × 2)     =   60  
Q  (28 × 4)     =  112  
U  (32 × 8)     =  256  
3  (3 × 16)     =   48  
0  (0 × 32)     =    0  
5  (5 × 64)     =  320  
4  (4 × 128)    =  512  
3  (3 × 256)    =  768  
8  (8 × 512)    = 4096  

• Sum of products:

13 + 60 + 112 + 256 + 48 + 0 + 320 + 512 + 768 + 4096 = 6185

• Divide the sum by 11:

6185 % 11 = 3

The check digit is 3.

Sample Output

>>> Enter a shipping container number: CSQU3054384
    CSQU3054384 is a not valid shipping container number
>>> Enter a shipping container number: CSQU3054383
    CSQU3054383 is a valid shipping container number

7. International Bank Account Number

The IBAN (International Bank Account Number) is a standardized format used to uniquely identify bank accounts internationally. Its structure varies by country but follows a general pattern defined in ISO 13616.

The general structure of an IBAN is the following:

[CC][CD][BBAN]

where:

• CC is the country code — two letters;
• CD is the check digit — two digits;
• BBAN is the Basic Bank Account Number (BBAN) — up to 30 alphanumeric characters that are country-specific.

IBAN Check Digit Calculation

To calculate or verify the two-digit check digits (CD) in an IBAN:

1. Substitute the check digits with “00”
2. Move the first 4 characters (country code and check digits) to the end
3. Convert letters to numbers using the mapping A = 10, B = 11, …, Z = 35
4. Convert the result to an integer and compute mod 97
5. Calculate the check digits as: 98 − result where result is from step 4
6. If the result is a single digit, pad with a leading zero

Example: GB82WEST12345698765432

• Replace the check digits with 00:

GB82WEST12345698765432 →
GB00WEST12345698765432

• Move the first 4 characters to the end:

WEST12345698765432GB00

• Replace all letters with their numeric equivalents:

3214282912345698765432161100

• Compute mod 97:

3214282912345698765432161100 % 97 = 16

• Calculate the check digits:

98–16 = 82

The check digits are: 82.

Sample Output

>>> Enter a IBAN number: GB16WEST12345698765432
    GB16WEST12345698765432 is a not valid IBAN number.
>>> Enter a IBAN number: GB32WEST12345698765432
    GB32WEST12345698765432 is a valid IBAN number.

8. Vehicle Identification Number

The VIN (Vehicle Identification Number) is a standardized 17-character code used worldwide to uniquely identify motor vehicles. Its structure is defined by ISO 3779, and each section encodes specific information about the vehicle.

A VNI is divided in three main parts:

1/ WMI — World Manufacturer Identifier (Positions 1–3)
- Position 1: Country code — 1 = USA, J = Japan, W = Germany, etc.
- Position 2: Manufacturer code — H = Honda, B = BMW, etc.
- Positon 3: Vehicle type or division — often specific to manufacturers.

2/ VDS — Vehicle Descriptor Section (Positions 4–8)

3/ Check Digit (Position 9)

4/ VIS — Vehicle Identifier Section (Positions 10–17)

Vehicle Identification Number Check Digit Calculation

The check digit is computed as follows:

1/ Replace the check digits with 0.

2/ Convert all letters to their numeric equivalents according the following transliteration table:

3/ Multiply each numeric value by its position weight listed in the following table:

4/ Sum all products.

5/ Compute mod 11.

6/ Determine the check digit:

• If the result is 10, the check digit is “X”.
• Otherwise, it’s the numeric result itself.

Example: 1HGCM82633A004352

• Replace the check digit (position 9) with 0:

1HGCM82603A004352

• Convert characters to numbers (transliteration):

1 H G C M 8 2 6 0 3 A 0 0 4 3 5 2 → 1 8 7 3 4 8 2 6 0 3 1 0 0 4 3 5 2

• Multiply by weights and sum:

1×8 + 8×7 + 7×6 + 3×5 + 4×4 + 8×3 + 2×2 + 6×10 + 0×0 + 3×9 + 
                          1×8 + 0×7 + 0×6 + 4×5 + 3×4 + 5×3 + 2×2 = 311

• Compute 311 % 11 = 3

The check digit is 3.

Sample Output

>>> Enter a VIN number: 1HGCM82613A004352
    1HGCM82613A004352 is a not valid VIN number.
>>> Enter a VIN number: 1HGCM82633A004352
    1HGCM82633A004352 is a valid VIN number.

9. Mexico Clave Bancaria Estandarizada

The CLABE (Clave Bancaria Estandarizada) is the standardized 18-digit bank account number used in Mexico for domestic electronic funds transfers. The last digit (18th) is a check digit that ensures the validity of the number and helps prevent input errors.

CLABE Check Digit Calculation

The CLABE check digit is computed as follows:

1. Multiply each of the first 17 digits (from left to right) by the repeating sequence of weights [3, 7, 1].
2. Reduce each product modulo 10.
3. Sum all these modulo-10 values.
4. Compute the check digit using the formula: (10 — (sum mod 10)) mod 10.

Example: 002010061493012344

• Multiply each digit (from left to right) by cyclic weights [3, 7, 1]:

3×0 + 7×0 + 1×2 + 3×0 + 7×1 + 1×0 + 3×0 + 7×6 + 1×1 + 3×4 +
                                7×9 + 1×3 + 3×0 + 7×1 + 1×2 + 3×3 + 7×4
= 0 + 0 + 2 + 0 + 7 + 0 + 0 + 42 + 1 + 12 + 63 + 3 + 0 + 7 + 2 + 9 + 28

• Reduce each product modulo 10

0 + 0 + 2 + 0 + 7 + 0 + 0 + 2 + 1 + 2 + 3 + 3 + 0 + 7 + 2 + 9 + 8

• Sum all these modulo-10 products

0 + 0 + 2 + 0 + 7 + 0 + 0 + 2 + 1 + 2 + 3 + 3 + 0 + 7 + 2 + 9 + 8 = 46

• Compute the check digit:

(10 - (46 % 10)) % 10 = 4

The check digit is 4.

10. Indian Goods and Services Tax Identification Number

The GSTIN (Goods and Services Tax Identification Number) is a 15-character alphanumeric identifier assigned to registered taxpayers in India under the GST system. It ensures uniqueness and includes a check digit (15th character) to detect input errors.

GSTIN Check Digit Calculation

1. Replace all letters in the first 14 characters. with their numeric equivalents: A = 10, B = 11, ..., Z = 35.
2. Multiply each digit/converted letter (from left to right) by cyclic weights [1, 3, 7].
3. Sum all the products
4. Compute mod 36 of the sum
5. Determine the check digit:

• If result < 10 → use digit 0–9
• If result ≥ 10 → convert to letter: 10 = A, 11 = B, ..., 35 = Z

Example: 27ABCDE1234F1Z4

• Replace all letters with their numeric equivalents (A=10 to Z=35):

A=10, B=11, C=12, D=13, E=14, F=15, Z=35
27ABCDE1234F1Z → 2 7 10 11 12 13 14 1 2 3 4 15 1 35

• Multiply each digit (from left to right) by cyclic weights [1, 3, 7]:

2×1 + 7×3 + 10×7 + 11×1 + 12×3 + 13×7 + 14×1 + 1×3 +
                                2×7 + 3×1 + 4×3 + 15×7 + 1×1 + 35×3
= 2 + 21 + 70 + 11 + 36 + 91 + 14 + 3 + 14 + 3 + 12 + 105 + 1 + 105

• Sum of all products:

2 + 21 + 70 + 11 + 36 + 91 + 14 + 3 + 14 + 3 + 12 + 105 + 1 + 105 = 488

• Compute mod 36:

488 % 36 = 4

• Determine check digit:

4 < 10 → Check digit = '4'

The check digit is is 4.

11. Norwegian National Identity Number

The Norwegian National Identity Number (Fødselsnummer) is an 11-digit personal identifier assigned to Norwegian citizens and residents. It encodes:

• 6 digits for the date of birth (DDMMYY)
• 3-digit serial number
• 2 check digits: k1 (digit 10) and k2 (digit 11)

First Check Digit (k1) Calculation

1. Multiply the first 9 digits by these fixed weights:
   [3, 7, 6, 1, 8, 9, 4, 5, 2]
2. Sum all the products.
3. Compute:
   k1 = (11 - (sum % 11)) % 11

Second Check Digit (k2) Calculation

1. Multiply the first 10 digits (including k1) by these weights:
   [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
2. Sum all the products.
3. Compute:
   k2 = (11 - (sum % 11)) % 11

Example: 01020322280

First check digit (k1):

• Multiply the first 9 digits by fixed weights: [3, 7, 6, 1, 8, 9, 4, 5, 2]

3×0 + 7×1 + 6×0 + 1×2 + 8×0 + 9×3 + 4×2 + 5×2 + 2×2

• Sum all products:

3×0 + 7×1 + 6×0 + 1×2 + 8×0 + 9×3 + 4×2 + 5×2 + 2×2 = 58

• Compute k1:

k1 = (11 - (sum % 58)) % 11 = 8

The first check digit k1 (digit 10) is 8.

Second check digit (k2)

• Multiply the first 10 digits by fixed weights [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]:

5×0 + 4×1 + 3×0 + 2×2 + 7×0 + 6×3 + 5×2 + 4×2 + 3×2 + 2×8

• Sum all products:

5×0 + 4×1 + 3×0 + 2×2 + 7×0 + 6×3 + 5×2 + 4×2 + 3×2 + 2×8 = 66

• Compute k2:

(11 - (sum % 66)) % 11 = 0

The second check digit k2 (digit 11) is 0.

12. German Sozialversicherungsnummer

The German Sozialversicherungsnummer (SVNR), or social security number uniquely identifies individuals within the social insurance system of Germany. The structure of a is formed of the following 4 parts:

AA BBBBBB C DDD

where:

• AA (2): Area number (insurance agency)
• BBBBBB (6): Birth date in DDMMYY
• C (1): Initial of last name
• DDD (3): Check digit + serial number

The 12th (last) digit is a checksum used to validate the number’s correctness.

SVNR Check Digit Calculation

This checksum is calculated using a modulo 10 algorithm with weighting.

1. Extract numeric parts (exclude the surname letter).
2. Apply alternating weights: 2, 1, 2, …
3. Multiply each digit by its weight.
4. If the product ≥10, sum the digits.
5. Add all these digit sums together.
6. Compute the check digit: (10 — s % 10) % 10 where s is the sum from step 5.

Example: 65 131277 M 01

1/ Extract numeric parts

From 65 131277 M 01, extract: 6513127701

2/ Apply alternating weights: 2, 1, 2, …

3/ Multiply each digit by its weight:

   2×6 + 1×5 + 2×1 + 1×3 + 2×1 + 1×2 + 2×7 + 1×7 + 2×0 + 1×1
 = 12 + 5 + 2 + 3 + 2 + 2 + 14 + 7 + 0 + 1

4/ If the product ≥10, sum the digits:

12 + 5 + 2 + 3 + 2 + 2 + 14 + 7 + 0 + 1 → 3 + 5 + 2 + 3 + 2 + 2 + 5 + 7 + 0 + 1

5/ Add all these digit sums together:

3 + 5 + 2 + 3 + 2 + 2 + 5 + 7 + 0 + 1 = 30

6/ Compute the check digit:

(10 - 30 % 10) % 10 = 0

The check digit is 30.

13. Mexican Clave Única de Registro de Población

The Mexican CURP (Clave Única de Registro de Población) is an 18-character alphanumeric identity code. The 18th character is a check digit calculated using a weighted sum modulo 10.

Mexican CURP has the following structure:

CURP Check Digit Calculation

1. Convert each of the 17 characters to a numeric value using A = 10, B = 11, …, N = 23, Ñ = 24, O = 25, …, Z = 35.
2. Multiply each value by a weight: 18 down to 2.
3. Sum all the products.
4. Compute check digit: (10 — (s % 10)) % 10 where s is the sum from step 3.

Example: GOCJ880323HMCLNS08

1/ Convert each of the 17 characters to a numeric value:

GOCJ880323HMCLNS0 ➝ 16 24 12 19 8 8 0 3 2 3 17 22 12 21 23 28 0

2/ Multiply each value by a weight:

  18x16 + 17x24 + 16x12 + 15x19 + 14x8 + 13x8 + 12x0 + 11x3 + 10x2 + 9x3 + 
  8x17 + 7x22 + 6x12 + 5x21 + 4x23 + 3x28 + 2x0
= 2112

3/ Compute check digit:

(10 - (2112 % 10)) % 10  = 8

The check digit is 8.

14. Spanish Número de la Seguridad Social

The Número de la Seguridad Social (NSS) is the Spanish Social Security Number, used to uniquely identify individuals in Spain’s social security and healthcare systems.

The structure of the NSS is the following:

PP NNNNNNNN CC

where:

• PP (2): Province code (01–52 for Spain’s provinces)
• NNNNNNNN (6–8): Personal sequence number (unique per person)
• CC (2): Checksum

Example: 08 12345678 29

1/ Left-pad the full number:

08 12345678 29 ➝ 812345678

2/ Compute the checksum:

(98 - (812345678 % 97)) = 29

3/ The checksum is 29.

15. CAS Registry Number (CAS RN)

A CAS Registry Number (CAS RN) is a unique numeric identifier assigned to every chemical substance described in the open scientific literature by Chemical Abstracts Service.

A CAS RN has three parts, separated by hyphens:

XXXXXXX - YY - Z

where:

First part (XXXXXXX)

• 2 to 7 digits
• No inherent chemical meaning
• Simply a serial number
• Grows as more substances are registered

Second part (YY)

• Exactly 2 digits
• Also has no chemical meaning
• Helps with formatting and uniqueness

Third part (Z) — the check digit

• Exactly 1 digit
• Used for error detection
• Calculated from the previous digits

CAS Check Digit Calculation

1. Remove all hyphens from the CAS string.
2. Set the last digit (the check digit) aside.
3. Working from right to left (starting from the digit immediately before the check digit), multiply each digit by its position index (1, 2, 3, …).
4. Sum these products.
5. Compute the value modulo 10. This result must match the check digit.

Example: 7732–18–5

Water: 7732–18–5

1/ Remove all hyphens:

7732–18–5 → 7732185

2/ Set the last digit (the check digit) aside:

7732185 → 773218

3/ Multiply each digit by its position index:

4/ Sum these products:

8×1 + 1×2 + 2×3 + 3×4 + 7×5 + 7×6 = 105

5/ Take the modulo 10 of the sum.

105 % 10 = 5

The check digit is 5.

16. Turkish Identification Number

The Turkish Identification Number, officially called T.C. Kimlik No, is a unique national identity number assigned to every citizen of Turkey.

Structure of the T.C. Kimlik No

The T.C. Kimlik No is a fixed 11-digit numeric identifier used to uniquely identify individuals in all official, legal, and administrative processes in Turkey:

D₁ D₂ D₃ D₄ D₅ D₆ D₇ D₈ D₉ D₁₀ D₁₁

where:

• The first digit D₁ cannot be 0.
• D₁₀ is the first check digit.
• D₁₁ is the second check digit.

TCKN Check Digit Calculation

To calculate the 10th digit D₁₀:

1/ Sum the digits in the odd positions:

Sodd = D₁ + D₃ + D₅ + D₇ + D₉

2/ Sum the digits in the even positions:

Seven = D2 + D4 + D6 + D8

3/ D₁₀ Calculation:

D₁₀ = ((Sodd × 7) − Seven) % 10

To calculate the 11th digit D₁₁:

4/ Sum the first 10 digits:

D₁ + D₂ + D₃ + D₄ + D₅ + D₆ + D₇ + D₈ + D₉ + D₁₀

5/ D₁₁ Calculation:

D₁₁ = (D₁ + D₂ + D₃ + D₄ + D₅ + D₆ + D₇ + D₈ + D₉ + D₁₀) % 10

Example: 21574521838

1/ Sum of even digits:

1 + 7 + 5 + 1 = 14

2/ Sum of odd digits:

2 + 5 + 4 + 2 + 8 = 21

3/ Calculation of D₁₀:

D₁₀ = ((21 * 7) - 14) % 10 = 3

4/ Sum the first 10 digits:

2 + 1 + 5 + 7 + 4 + 5 + 2 + 1 + 8 + 3 = 38

5/ Calculation of D₁₁:

D₁₁ = 38 % 10 = 8

The check digits are 38.

17. South African ID Number

A South African ID Number is a 13-digit numeric identifier assigned to citizens and permanent residents of South Africa.

Structure of the South African ID Number

A South African ID Number is a 13-digit numeric identifier:

YYMMDD SSSS C A Z

where:

• YYMMDD is the date of birth
• SSSS encodes the gender: 0000–4999 → Female, 5000–9999 → Male
• C indicates legal status: 0 → South African citizen, 1 → Permanent resident
• A reserved for future administrative use, historically fixed at 8
• Z is the check digit

South African ID Number Check Digit Calculation

1. Remove the check digit (if present). This leaves the first 12 digits of the ID number, known as the payload.
2. Process the payload digits from left to right. Double every second digit, starting with the second digit (i.e., digits in even positions).
3. Reduce doubled values greater than 9 by subtracting 9 (equivalently, summing the digits of the result).
4. Sum all digits, including both the modified and unmodified digits. Let this sum be S.
5. Compute the check digit using: Check digit = (10−(S mod 10)) mod 10.

Example: 9002156789080

1/ Remove the check digit:

9002156789080 → 900215678908

2/ Double every second digit, starting with the second digit:

   1×9 + 2×0 + 1×0 + 2×2 + 1×1 + 2×5 + 1×6 + 2×7 + 1×8 + 2×9 + 1×0 + 2×8
 = 9 + 0 + 0 + 4 + 1 + 10 + 6 + 14 + 8 + 18 + 9 + 16

3/ Reduce doubled values greater than 9 by subtracting 9:

   9 + 0 + 0 + 4 + 1 + (1+0) + 6 + (1+4) + 8 + (1+8) + 0 + (1+6)
 = 9 + 0 + 0 + 4 + 1 + 1 + 6 + 5 + 8 + 9 + 0 + 7

4/ Sum all digits:

9 + 0 + 0 + 4 + 1 + 1 + 6 + 5 + 8 + 9 + 0 + 7 = 50

5/ Compute the check digit:

(10−(59 mod 10)) mod 10 = 0

The check digit is 0.

18. EAN-8 Barcode

The EAN-8 (European Article Number) is a compact 8-digit barcode used to identify products when space is limited (e.g., small packages). It is standardized and administered by GS1.

Structure of the EAN-8 Barcode

The EAN-8 consists of 8 digits:

D1 D2 D3 D4 D5 D6 D7 Z

where:

• D1–D7: Product identifier (assigned by GS1 member organizations)
• Z: Check digit (error detection)

EAN-8 Check Digit Calculation

The check digit Z is computed from the first 7 digits using a modulo-10 weighted sum:

1. Take the first 7 digits (exclude the check digit).
2. Starting from the right, multiply digits by alternating weights 3, 1, 3, 1, ….
3. Sum the weighted values → call the sum S.
4. Compute: Z = (10 − (S % 10)) % 10.

Example: 73513537

1/ Take the first 7 digits:

73513537 → 7351353

2/ Starting from the right, multiply digits by alternating weights 3, 1, 3, 1, ….

(3×3) + (5×1) + (3×3) + (5×1) + (1×3) + (3×1) + (7×3)

3/ Sum the weighted values:

(3×3) + (5×1) + (3×3) + (5×1) + (1×3) + (3×1) + (7×3) = 63

4/ Compute the check digit:

(10 − (63 mod 10)) mod 10 = 7

The check digit is 7.

Each problem strengthens your understanding of loops, string manipulation, and number logic — without needing advanced libraries or algorithms. Whether you’re preparing for interviews or just looking for a fun practice set, this list offers the right mix of creativity and challenge.

Summary Table

Easy: Basic Digit and String Manipulation

01 - Count Palindromic Numbers

Count how many numbers from 1 to N are palindromic numbers. A palindromic number is a number that reads the same forwards and backwards.

Examples:

101, 111, 121, 131, 141 → ✅

100, 110, 122, 113 → ❌

Output:

For N = 100, there are 19 palindromic numbers (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99).

Main Challenge: String reversal and comparison.

02 - Most Common Digit Sum

Compute the sum of digits for numbers from 1 to N, and find the digit-sum that appears most often.

Examples:

123 → 1 + 2 + 3 = 6

234 → 2 + 3 + 4 = 9

Output :

For N = 1000, the digit-sum that appears the most often is 13 and 14. They appear 75 times.

Main Challenge: Digit sum computation and frequency count.

03 - Unique Digits Only

Count how many numbers from 1 to N have no repeating digits.

Example:

121 → ❌

123 → ✅

Output:

For N = 1000, there are 738 numbers with no repeating digits.

Main Challenge: Duplicate detection in digits.

04 - Consecutive Repeating Digits

Count how many numbers from 1 to N contain at least one pair of consecutive identical digits.

Example:

122 → has "22"

345 → no consecutive repeats

Output:

For N = 1000, there are 181 numbers with one sequence of consecutive identical digits.

Main Challenge: Pattern recognition within digits.

05 - Harshad Number

Count how many numbers from 1 to N are Harshad (aka Niven) numbers. A A Harshad number is a number that is divisible by the sum of its digits.

Examples:

21 → 2 + 1 = 3 → 21 % 3 == 0 ✅

23 → 2 + 3 = 5 → 23 % 5 ≠ 0 ❌

Output:

For N = 1000, there are 213 Harshad numbers.

Main Challenge: Modulo check with digit sum.

Intermediate: More Logic or Multi-Step Checks

06 - Lucky Numbers

Count how many numbers from 1 to N are lucky numbers. A number is lucky if the sum of the first half of its digits equals the sum of the second half.

Examples:

1230 → 1+2 == 3+0 → ✅

17908 → 1+7 == 0+8 → ✅

Output:

For N = 1000, there are 108 lucky numbers.

Main Challenge: Slicing and comparing digit sums.

07 - Digit Sum Equals Product

Count all numbers in the range 1 to N where the sum of digits equals the product of digits.

Example:

123 → 1 + 2 + 3 = 6, 1 * 2 * 3 = 6 → ✅

22 →  2 + 2 = 4,  2 * 2 = 4 → ✅

Output:

For N = 1000, there are 16 numbers where the sum of digits equals the product of digits.

Main Challenge: Digit math and logical comparison.

08 - Armstrong Numbers

Count all Armstrong numbers (aka narcissistic numbers) up to N. A number is Armstrong if the sum of each digit power to the number of digits is the number itself

Examples:

153 → 1³ + 5³ + 3³ = 153

9474 → 9⁴ + 4⁴ + 7⁴ + 4⁴ = 9474

Output:

For N = 1000, there are 14 Armstrong numbers. (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407).

Main Challenge: Exponentiation with dynamic digit length.

09 - Digital Roots Count

Find the most common digital root for numbers from 1 to N. The digital root is the iterative sum of digits until a single digit remains.

Example:

Digital root of 987 is 6: 9 + 8 + 7 = 24 → 2 + 4 = 6

Output:

For N = 1000, the most common digital root is 1. 1 is the digital root for 112 numbers.

Main Challenge: Recursion or repeated digit sum.

10 - Increasing Digit Subsequence

Count how many numbers from 1 to N contains a strictly increasing sequence of digits.

Examples:

123 → digits increasing (1 < 2 < 3) → count it

132 → not increasing → skip

Output:

For N = 1000, there are 219 numbers that contains a strictly increasing sequence of digits.

Main Challenge: Strict order comparison of digits.

Advanced: Complex logic, Iteration & Recursion

11 - Reduce to Zero by Subtracting the Max Digit

For each number from 1 to N, repeatedly subtract its largest digit until the number becomes zero. Count how many steps this process takes, and find how many numbers share the max step count.

Example:

For number 57:
Step 1: 57 - 7 = 50
Step 2: 50 - 5 = 45
Step 3: 45 - 5 = 40
Step 4: 40 - 4 = 36
...
Step 10: 10 - 1 = 9
Step 11: 9 - 9 = 0

For 57, it took 11 steps to reach 0.

Output:

For N = 99, the max step count is 16 and 6 numbers share this step count (94, 95, 96, 97, 98, 99).

Main Challenge: Iterative reduction with max tracking.

12 - Reverse and Add Until Palindrome

Reverse the digits for each number from 1 to N and add to the original number repeatedly until a palindrome forms. Find the numbers in range 1 to N that require the most iterations to reach a palindrome.

Example:

For number 87:

Step 1: 87 + 78 = 165 (not palindrome)

Step 2: 165 + 561 = 726 (not palindrome)

Step 3: 726 + 627 = 1353 (not palindrome)

Step 4: 1353 + 3531 = 4884 (palindrome!) → stop.

For 87, it took 4 steps to reach a palindrome.

Output:

For N = 100, it took 24 iterations for numbers 89 and 98 to reach palindrome 8813200023188.

Main Challenge: Recursion and palindrome detection.

13 - Most Frequent Digit Count

Count the number of times the most frequent digit appears in numbers from 1 to N.

Examples:

Numbers from 1 to 13:
Digits are: 1,2,3,4,5,6,7,8,9,1,0,1,1,1,2,1,3
Digit counts:

'1': appears 6 times

'2' and '3': appear 2 times

Others: 1 time each

So, the most frequent digit is 1, and it appears 6 times.

Output:

For N = 9999, digit 1 appears 4000 times.

Main Challenge: Full range digit analysis and counting.

14 - Roman Numerals Count

Convert numbers from 1 to N to Roman numerals, count how many times the most frequent Roman letter (e.g., ‘X’ or ‘I’) appears in all these Roman numerals combined.

Examples:

1994 → MCMXCIV

58 → LVIII

Output:

For N = 999, ‘X’ and ‘C’ are the most frequent Roman letters. They appear 148 times.

Main challenge: Roman conversion and symbol counting.

15 - Number to Words

Convert a number into its plain English words and count how many times a specific letter appears in the result.

Examples:

123 → "one hundred twenty-three"

9999 → "nine thousand nine hundred ninety-nine"

Output:

Letter ‘n’ appears 10 times in 9999 (nine thousand nine hundred ninety-nine).

Main Challenge: Number-to-word conversion and filtering.

Next time you’re eating with friends or colleagues, take a moment to observe the table. You’ll often notice that those who finish their meals last tend to be slimmer, while the faster eaters are more likely to carry extra weight. Why is that?

The answer lies in the communication delay between your stomach and your brain.

Eat Slow, Lose More

It’s no secret that weight loss comes down to consuming fewer calories. But how do you eat less without feeling starved? The key lies in tuning into your body’s natural satiety cues — the internal signals that tell you when you’ve had enough.

But here’s the catch: it takes about 20 minutes for your brain to register that your stomach is full. During those first 20 minutes, your body is basically in “all-you-can-eat” mode. Only after that point does your brain send the signal to stop.

Since you can’t speed up this 20-minute delay, the smart move is to slow down your eating. Doing so gives your brain the time it needs to catch up — helping you naturally eat less, without feeling like you’re missing out.

The following three strategies are easy, low-effort ways to reduce your eating speed and improve portion control — all while enjoying your food more mindfully.

Tip #1: Put the Fork on the Table Between Each Bite

Why it works

Freeing your hands from cutlery helps break the automatic rhythm of eating. When your hands aren’t constantly guiding food to your mouth, you interrupt the mechanical pace that often leads to overeating. This built-in pause encourages you to chew more slowly, giving your body time to digest and register fullness.

Practical tips

• After each bite, place your fork down and focus on chewing thoroughly.
• Use the pause to engage with your senses — texture, taste, smell — or chat with your dining companion.
• Try chewing each bite 20–30 times; this not only slows you down but helps digestion.

Tip #2: Use Your Non-Dominant Hand to Eat

Why it works

When you eat mindlessly, it’s easy to consume more than you need. Switching to your non-dominant hand introduces just enough awkwardness to interrupt this automatic behavior. The slight clumsiness forces you to focus on the act of eating, making it a more deliberate experience. By requiring conscious coordination, this simple trick helps you slow down and makes it harder to overeat.

Practical tips

• Try it with simple meals first (e.g., salads, rice bowls, pasta, or sandwiches).
• If it feels too awkward at first, practice this technique in a low-pressure setting (e.g., lunch or dinner at home).
• Combine this method with other mindfulness techniques (e.g., no phones or TV while eating).

Tip #3: Use a Dessert Fork for Smaller Bites

Why it works

Using smaller utensils is a simple way to reduce the size of your bites. Dessert and fruit forks are intentionally smaller than standard table forks. They are designed for lighter, more refined portions. Smaller bites mean more individual bites per meal and more time spent eating. Chewing these smaller bites thoroughly helps you get closer to the crucial 20-minute mark while consuming less food overall.

Practical tips

• Swap your standard fork for a dessert or salad fork.
• Use chopsticks if you’re not proficient with them.
• Avoid overloading small fork. Keep the bites truly bite-sized.

Bonus Tip: Drink Water 20 Minutes Before Meals

Why it works

Drinking a glass of water 20 minutes or so before eating gently expands your stomach, triggering stretch receptors that signal early fullness. This improves digestion and helps regulate how muc you eat.

Drinking during meals, however, may have the opposite effect. It dulls taste perception, making food seem less flavorful and possibly leading you to eat more to feel satisfied.

Practical tips

• Drink a glass of water 20 minutes before meals to naturally reduce appetite.
• Sip water during meals sip only if necessary to aid swallowing.
• Minimize water intake with food to better enjoy flavors and feel more satisfied.

Takeaway

Weight loss doesn’t have to mean deprivation or hunger. All you need is to slow down your eating. This will allow your natural satiety cues guide you. When you give your body enough time to register fullness, you’ll likely consume fewer calories without feeling restricted.

The three strategies I shared in this article are easy to incorporate into your daily routine and don’t require special diets, calorie counting, or willpower. You can pair them for even better results. These strategies reinforce each other, making it easier to break mindless eating habits and tune into your body’s natural hunger cues.

Understanding and using the compound data types effectively can greatly improve the efficiency and organization of your Python code.

Download the Aide-Mémoire

This comprehensive aide-mémoire is completely free and easily accessible online. It covers the main compound data types of Python 3 with examples.

To improve the efficiency and organization of your Python code, do yourself a favor and utilize this cheat sheet. Download the cheat sheet here.

What is a Compound Data Type?

Compound data types in Python are types that can hold multiple items or values. They are used to group together multiple values and can be of different data types.

my_list = [1, 1, 2, 'A', 'B', 'C']
my_tuple = (1, 1, 2, 'A', 'B', 'C') 
my_set = {1, 2, 'A', 'B', 'C'}
my_dictionary = {1:'A', 2:'B', 3:'C'}
my_string = '112ABC'
my_bytes = b'112ABC'
my_bytearray = bytearray(b'112ABC')

Compound data types provide various ways to group and manipulate multiple items in Python, allowing for efficient data management and operations.

What are the Compound Data Types in Python?

In Python, the main compound types are:

• List
• Tuple
• Set
• Dictionary
• String
• Bytes
• Bytearray

Similarities and Differences among Python Compound Data Types

In Python, compound data types share some similarities but also exhibit certain differences. Understanding these can help you choose the right type for your needs.

Similarities

1. Iterable: All compound data types are iterable, meaning you can loop over their elements.
2. Contain Multiple Elements: They can hold multiple items or elements.
3. Support Membership Testing: You can use the in and not in keywords to check for the presence of an element.
4. Indexable: Lists, tuples, strings, bytes, and bytearrays support indexing, allowing you to access elements by their position.
5. Support for Common Operations: You can perform operations like len() to get the number of elements.

Differences

1. Mutability: Mutability refers to the ability of an object to change its state or contents after it has been created. Immutable data types make better use of memory through memory sharing, optimization, elimination of defensive copies, and simpler memory management.

• Mutable: Lists, sets, dictionaries, bytearrays.
• Immutable: Tuples, strings, bytes.

2. Order: The order in which the elements are specified when the object is defined is maintained for the object’s lifetime unless explicitly changed.

• Ordered: Lists, tuples, strings, bytes, bytearrays.
• Unordered: Sets, dictionaries (though dictionaries maintain insertion order since Python 3.7).

3. Uniqueness: Some compound data types allow for duplicate elements to be added.

• Unique Elements: Sets and dictionary keys.
• Duplicated Elements: Lists, tuples, strings, bytes, bytearrays.

4. Indexing and Slicing: Indexing refers to the process of accessing a specific element in a sequence using its position or index number. Slicing refers to the method of extracting a portion of a sequence.

• Supports Indexing and Slicing: Lists, tuples, strings, bytes, bytearrays.
• Does Not Support Indexing and Slicing: Sets, dictionaries (access elements via keys in dictionaries).

5. Access times vs memory usage:

• Sets and dictionaries are best for fast searches due to their underlying hash table implementation. Highly efficient lookups come at the cost of higher memory usage due to the metada required to manage the hash table structure.
• Tuples and strings are more memory-efficient due to their immutability and fixed size.
• Lists are less efficient than tuples because they are mutable and may require extra space for dynamic resizing and additional memory management overhead.

Summary of Compound Data Types

The similarities and differences among Python Compound Data Types are summarized in the following table:

About the Author

Promethee Spathis is a Professor of Practice in Computer Science at NYU Shanghai. He is also a Senior Associate Professor in the Faculty of Science & Engineering at Sorbonne Université, France. He received both his Masters and PhD degree in Computer Science from Sorbonne Université.

With a primary focus on Computer Science, Professor Spathis has designed and developed a wide array of courses spanning B.Sc, M.Sc, and Ph.D. levels. At NYU Shanghai, he currently teaches courses in computer networking and computer programming, bringing his extensive expertise and innovative teaching methods to the classroom. His commitment to education and research continues to inspire and shape the next generation of computer scientists.

Keywords

Python Cheat Sheet, Python Quick Reference, Python Tips and Tricks, Python for Beginners, Python Programming Guide, Python Syntax Cheat Sheet, Python Coding Shortcuts, Python Basics, Python Code Snippets, Python Essential Commands, Learn Python Quickly, Python One-liners, Python Reference Guide, Python Programming Basics, Python Developer Tools, Python Quick Tips, Python Code Examples

Learning and remembering every fact about a new topic can be challenging, if not impossible. Cheat sheets are crafted to help you memorize and recall essential information swiftly, making them an efficient tool for learning and using new technologies.

The cheat sheet provided in this article is an invaluable resource for both beginners and experienced developers. For novices, it lowers the entry barrier, making Python more approachable. For experts, it serves as a quick refresher to sharpen their skills.

Download the Cheat Sheet

This comprehensive cheat sheet is completely free and easily accessible online. It covers over 95% of all Python 3 commands with examples. At the end of this article, you’ll find the detailed list of all topics covered. To make your learning process smoother and faster, do yourself a favor and utilize this cheat sheet. Download the cheat sheet here.

What Are Cheat Sheets?

Cheat sheets are indispensable tools. They come in handy to students in preparation of or during their exams but also to professionals who can use them as concise quick reference guides.

Cheat sheets provide a condensed, easy-to-access reference for key information. They allow beginners and experts to quickly look up important details without having to search through extensive documentation or manuals.

A well designed cheat sheet usually fits on one page and holds all the information related to one topic. Designing a cheat sheet can be challenging as they need to be both readable while being holistic.

Cheat Sheets for Computer Science

Cheat sheets for Computer Science are particularly useful. They contain all the most essential information about a specific subject or domain into a short format, covering syntax, commands, functions, shortcuts, and hotkeys.

Programming and software cheat sheets are extremely popular amongst computer science students and professionals who can quickly access information at one glance such as the syntax, commands, functions, shortcuts, or hotkeys.

Benefits of Programming Cheat Sheets

Cheat sheets are valuable tools for both novice and experienced programmers. Here are some key benefits of Python Cheat sheet:

1. Quick Reference: They save time by providing immediate answers to common questions.
2. Learning Aid: They help reinforce learning by summarizing key concepts.
3. Consistency: They promote adherence to coding standards and best practices.
4. Productivity: They improve coding efficiency by offering quick solutions and reminders.
5. Advanced Features: They include less frequently used commands or features that might not be memorized.
6. Teaching and Collaboration: They are invaluable for teaching and assisting students with new concepts.
7. Compact and Portable: They are easy to carry and use in different environments, whether online or offline.
8. Improved Code Quality: They help in writing cleaner and more efficient code by providing examples and best practices.
9. Self-Reliance: They encourage independent problem-solving and learning.
10. Motivation: They can inspire beginners to explore further and experts to keep their skills sharp.

In summary, cheat sheets are versatile tools that enhance learning, improve productivity, ensure consistency, and promote best practices. They serve as an indispensable resource for both students and professionals in the programming community.

Python Cheat Sheet

The spread sheet I give below is completely free and easily accessible online. It contains over 95% of all Python 3 commands with examples. So remember, to make your learning process smoother and faster, utilize this cheat sheet.

To download the Python cheat sheet click here.

Topics Covered in the Cheat Sheet

This cheat sheet covers the following concepts:

Page 1

Data Types

• Text Type: str
• Numeroc Type: int, float, complex
• Boolean Type: bool
• Sequence Types: List (list), Tuple (tuple), Range (range)
• Set Type: Set (set)
• Mapping Type: Dictionary (dic)

Data Type Conversions

• Integer and Float Conversions: float(), int()
• Real to Complex Data Type Conversion: complex()
• Data Type Conversion with Strings: int(), str()
• Type Conversion to Tuples and Lists: tuple(), list()
• Type Conversion to Dictionaries and Sets: set(), dict()
• Convert Binary to Decimal: bin(), int()
• Convert Hexadecimal to Decimal: hex(), int()
• Convert Text to Decimal: ord(), chr()

Booleans

• Booleans as Numbers
• Comparison Operators: ==, !=, <, >, <=, >=
• Membership and Identity Operators: in, not in, is, is not
• Boolean Operators: not, and, or

Operator Precedence

Print Function

• print(), sep, end

User Input

• input()

Decision Structure

• if-then-elif-else statements

Repetition Structures

• While statement
• For statement

Exceptions

• FileNotFoundError, IndexError, KeyError, ModuleNotFoundError, NameError, SyntaxError, TypeError, ValueError, ZeroDivisionError

Modules

• import statement
• from… import statement

Files

• open(), close(), read(), readline(), readlines()
• access modes: read, write, append, create

Strings

• String Delimiters: single quotes, double quotes, triple single quotes, triple double quotes
• Escape Sequences
• String Operations: concatenation, repetition
• String Length: len()
• Unicode Code/Text Conversion: ord(), chr()
• String Membership: in, not in
• String Indexing
• String Slicing
• String Slicing Steps
• String Methods: upper(), lower(), isupper(), islower(), count(), endswith(), find(), index(), isalnum(), isalpha(), isdecimal(), isdigit(), isnumeric(), strip(), rstrip(), lstrip(), split(), replace()
• Iterating over Strings

Page 2

Lists

• List Creation: list()
• List Comprehension
• List Indexing
• List Slicing
• List Length: len()
• List Membership: in, not in
• List Comparison: ==, !=, <, >, <=, >=
• List Manipulation
• List Concatenation and Repetition
• Adding Elements: append(), extend(), insert()
• Removing Elements: remove(), pop()
• Deleting Elements: del
• List Counting, Searching, and Sorting: count(), index(), reverse(), sort()
• String-to-List and Back: split(), join()
• List Built-in Functions: all(), any(), len(), list(), max(), min(), reversed(), sorted(), sum(), tuple(), zip()
• Iterating over Lists

Tuples

• Tuple Creation: tuple()
• Tuple Unpacking
• Tuple Built-in Functions: all(), any(), count(), enumerate(), filter(), index(), len(), list(), map(), max(), min(), next(), reversed(), slice(), sum(), sorted(), tuple(), zip()
• Tuple Operations: indexing, slicing, concatenation, repetition, membership
• Iterating over Tuples

Sets

• Set Creation: set()
• Adding Elements: add(), update()
• Removing Elements: remove(), discard()
• Set Operations: union, intersection, difference, symmetric difference, subset, superset
• Iterating over Sets

Dictionaries

• Dictionary Creation: dict()
• Dictionary Length: len()
• Key Membership: in, not in

Retrieving a Value Given a Key

• get()

Adding a Key/Value Pair

Updating a Key/Value Pair

Deleting a Key/Value Pair

• del()

Dictionary Methods

• get(), items(), keys(), pop(), popitem(), update(), clear()

Iterating over Dictionaries

Similarities & Differences

• Ordered
• Duplicates allowed
• Mutable
• Comparison
• Access elements
• Slicing
• Concatenation,
• Repetition
• Iteration

About the Author

Promethee Spathis is a Professor of Practice in Computer Science at NYU Shanghai. He is also a Senior Associate Professor in the Faculty of Science & Engineering at Sorbonne Université, France. He received both his Masters and PhD degree in Computer Science from Sorbonne Université.

With a primary focus on Computer Science, Professor Spathis has designed and developed a wide array of courses spanning B.Sc, M.Sc, and Ph.D. levels. At NYU Shanghai, he currently teaches courses in computer networking and computer programming, bringing his extensive expertise and innovative teaching methods to the classroom. His commitment to education and research continues to inspire and shape the next generation of computer scientists.

Keywords

Python Cheat Sheet, Python Quick Reference, Python Tips and Tricks, Python for Beginners, Python Programming Guide, Python Syntax Cheat Sheet, Python Coding Shortcuts, Python Basics, Python Code Snippets, Python Essential Commands, Learn Python Quickly, Python One-liners, Python Reference Guide, Python Programming Basics, Python Developer Tools, Python Quick Tips, Python Code Examples

Learning and remembering every facts about a new topic is difficult and sometimes impossible. Cheat sheets are designed to help you memorize and recall essential information quickly, making them an efficient way to learn and use new technologies.

The cheat sheet provided in this article are invaluable resources for both beginners and experienced engineers. They can be used to lower the entry barrier for novices and help experts refresh their internet skills.

Download the Cheat Sheets

These two comprehensive cheat sheets are completely free and easily accessible online. They cover all IPv4/IPv6 headers and more protocols such as TCP, UDP, DNS, and ICMP. At the end of this article, you’ll find the detailed list of all topics covered. To make your learning process smoother and faster, do yourself a favor and utilize this cheat sheet. Download the cheat sheets here.

What Are Cheat Sheets?

Cheat sheets are amazing tools. They come in handy to students in preparation of or during their exams but also to professionals who can use them as concise quick reference guides.

Cheat sheets provide a condensed, easy-to-access reference for key information. They allow beginners and experts to quickly look up important details without having to search through extensive documentation or manuals.

A well designed cheat sheet usually fits on one page and holds all the information related to one topic. Designing a cheat sheet can be challenging as they need to be readable while being holistic.

Cheat Sheets for Computer Science

Cheat sheets for computer science contain all the most essential information about a specific subject or domain in short, such as the syntax, commands, functions, shortcuts, or hotkeys.

Programming and software cheat sheets are extremely popular amongst computer science students and IT professionals who can quickly access information at one glance. This is also true for computer networking.

Cheat sheets for Internet technologies can be useful for beginners who want to get started with a new technology, or for experts who want to refresh their memory on some details. They summarize a wide range of topics and concepts into a compact format that can be used for quick reference of a particular protocol or service.

Benefits of Computer Networking Cheat Sheets

Computer networking involves a wide range of protocols and services. Each protocol comes with its own header consisting of various fields. Details regarding a field include its name, its position, its length, and the list of values it can hold, each value carrying a specific meaning.

The two spread sheets I give below are completely free and easily accessible online. So remember, to make your learning process smoother and faster, utilize these cheat sheets.

TCP/IP Cheat sheet

To download the TCP/IP cheat sheet click here. This cheat sheet covers the following concepts:

• Link layer: Ethernet frames, ARP requests and responses.
• IPv4 addresses: IPv4 classes, IPv4 special-purpose addresses
• IPv4 packets: IPv4 header, IPv4 options, IPv4 pseudo-header
• ICMP messages: Destination unreachable, Time Exceeded, Parameter Problem, Redirect Message, Echo request and reply
• Transport Layer: TCP segment, TCP options, UDP datagrams, Well-known port numbers.
• Application layer: DNS Messages

IPv6 Cheat Sheet

To download the IPv6 cheat sheet click here. This cheat sheet covers the following concepts:

• IPv6: IPv6 Addresses, IPv6 Packet Header, Header Extensions (Routing and Fragment), IPv6 Pseudo-header.
• ICMPv6: Destination Unreachable (Type 1), Packet Too Big (Type 2), Time Exceeded (Type 3), Parameter Problem (Type 4), Echo Request and Reply (Type 128 and 129).
• Neighbor Discovery Options: Source and Target Link-Layer Address Options (Type 1 and 2), Prefix Information Option (Type 3), Redirected Header Option (Type 4), MTU Option (Type 5),
• Neighbor Discovery Messages: Router Solicitation (Type 133), Router Advertisement (Type 134), Neighbor Solicitation (Type 135), Neighbor Advertisement (Type 136), Redirect (Type 137).
• Multicast Listener Discovery

Further Readings

Here is a list of books where you will find more details on Internet protocols and technologies:

• Technologies et protocoles Internet, Promethee Spathis, Ellipses Editions, 2023.
• Computing Networking: A Top Down Approach, 8th edition, J.F. Kurose & K.W. Ross. Pearson/Addison-Wesley.
• Computer Networks: A Systems Approach, Larry L. Peterson, 6th Edition, Morgan Kaufmann.
• Computer Networks and Internets, Douglas E. Comer, 6th Edition, Chapman and Hall/CRC.
• TCP/IP Illustrated: The Protocols (Volume 1), Kevin Fall & W. Stevens, 2nd Edition, Addison-Wesley.

Comment faire pour acquérir une SwatchXOmega sans se ruiner ? Que faut-il savoir avant de se lancer ? A quoi faut-il s’attendre ? Je partage ici mon expérience dans ma quête d’une Moonwatch et mon avis sur les collaborations en général.

SwatchXOmega, qu’est ce que c’est ?

Si vous lisez cet article, c’est que vous connaissez déjà les prémisses de cette collaboration. Dans ce cas, vous pouvez sauter cette section.

Pour les autres, il s’agit de onze montres co-brandées Swatch et Omega dont les modèles sont inspirés des corps célestes du système solaire :

• Le Soleil.
• Les 9 planètes : Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune et Pluto.
• La Lune.

Le design est inspiré du fameux chronographe Omega Speedmaster, première montre à être allée sur la Lune lors la mission Apollo 11 en 1969. Tout comme la Speedmaster, l’anneau extérieur est gradué avec le “dot over 90 (DON)”, du point en diagonale du chiffre 70 et de l’accent grave sur le premier E de tachymètre. Le cadran comprend les 3 compteurs en creux. Le bracelet est en velcro et frappé des logos Swatch, Omega Ω et Speedmaster.

La comparaison s’arrête là puisque le mouvement et les matériaux sont ceux utilisés par Swatch. Le boîtier est en biocéramique, un mélange de céramique et d’huile de ricin qui, en remplaçant le plastique, rend les montres plus éco-responsable (?). Le verre est en plexiglas et ultrasensibles aux rayures. Par contre, à la manière des Rolex dont le saphir est gravé au laser avec une couronne, le plexiglas des Moonwatch est frappé de la lettre ‘S’ au centre du plexiglas. Si vous le trouvez, faites le savoir dans les commentaires. Moi je ne le vois pas.

Chaque modèle reprend les couleurs du corps célestes qu’il célèbre : le modèle Soleil est jaune, le modèle Terre est vert (même si on parle de Planète Bleue), Venus est rose, Mars est rouge, Neptune est bleu (c’était le Dieu des Mers dans la mythologie, n’est-ce-pas ?)… Le couvercle de la pile représente l’image du corps céleste dont s’inspire le modèle.

Samedi 23 avril, 10h00

Arrivée le samedi matin aux environs de 10h du matin, le 23/04 à l’angle des rues de Sèvre et du Cherche midi. On y trouve des capuches rabattues sur des casquettes, des baskets et des joggings, une odeur qui rappelle les rues d’Amsterdam. On se croit à proximité d’un McDo vu le nombre de livreurs à vélo qui font des rondes. Je me dis quelque chose se trame. Je demande aux agents de sécurité en faction devant la porte de la boutique. Ils restent vagues concernant la disponibilité.

Je savais, pour avoir posé la question il y deux semaines, que des montres étaient mises en vente sans savoir quand mais toujours en quantité limitée. « On en a eues ce matin mais elles sont toutes parties. » Hoax ou vérité ?

Je décide de camper à quelques pas sous les testic… du Centaure de César. Certains sont installés sur des chaises de camping. La police fait des rondes. L’ambiance reste bon enfant. L’accès à la boutique et le trottoir restent dégagés. Tout le monde est en arc de cercle. Le 26 mars, jour du lancement officiel, ce n’était pas la même. Des échauffourées avaient précipité la fermeture de la boutique et l’annulation de la vente.

J’ai une vue directe sur l’intérieur de la boutique. Sur les coups de midi, je vois les vendeurs faire des allers-retours fréquents, depuis et vers l’arrière-boutique. Je décide de m’approcher davantage. On est quelques-uns. Les habitués, eux, ne sont pas émus pour autant et restent sur les trottoirs opposés.

Et c’est là où, tout d’un coup, tout se précipite. Des vigiles habillés de noir, surgissent de nulle part et commencent à tirer le long du trottoir, des poteaux à sangle rétractable. L’un d’eux m’interpelle :

- Monsieur, vous devez partir, vous n’êtes pas sur la liste.

- Quelle liste ? Il y a une liste ?

- Oui Monsieur.

- Mais Monsieur, je ne suis pas au courant d’une quelconque liste. S’agit-il d’une liste officielle Swatch ?

“Monsieur, mettez-vous en face”, me dit-il de manière autoritaire, en me montrant le trottoir opposé.

- Le trottoir est un espace public et je suis libre d’y rester. Dites-moi où est la file pour que je m’y mette.

Un de ses collègues lui dit de se contenter de déployer les poteaux.

Apparaît alors un individu en jogging que tout le monde semble écouter. J’entends des voix qui l’identifient comme étant la même personne qui gère les ventes chez Nike. Sans doute celles des Jordan ou autres modèles qu’on voit dans les pubs pour StockX sur Facebook. Il nous invite, moi et ceux qui avions pris position devant la boutique, à quitter le trottoir pour celui d’en face. Il s’adresse à moi :

- Monsieur, oui il y a une liste et vous n’y êtes pas.

- Comment je fais pour m’y mettre ? Je suis là depuis 10h du matin et personne ne m’a parlé d’une liste. Est-ce une liste officielle swatch ?

- Monsieur, tout le monde est là depuis 5 heures du matin. Tout le monde s’est mis sur la liste. Vous voulez acheter, vous devez être sur la liste. Mettez-vous sur le côté et je vous promets de vous laisser passer.

Un vendeur sort et s’adresse aux vigiles en me montrant :

- Le Monsieur est là, il est le premier dans la file, laissez le entrer.

Parallèlement, un grondement s’élève dans la rue du Cherche Midi où la file commence à s’étendre. On se chamaille pour avoir les meilleures places. À moins que ce soit pour faire respecter l’ordre de la fameuse liste.

Quelques adolescents qui m’avaient suivi, cèdent aux intimidations et quittent la file. Les individus qui se retrouvent derrière moi m’interpellent.

- Vous n’avez pas le droit d’être là, Monsieur. C’est pas juste. On est là depuis 5 heures du matin. On est là pour se faire un petit billet.

Malgré le ton agressif, je reste calme et courtois.

- Si on m’avait parlé de la liste en arrivant, je respecterai l’ordre de passage.

- Vous n’avez pas demandé. C’est à vous de demander pour la liste.

- Si je ne connais pas l’existence de la liste, comment demander à y être ou savoir à qui m’adresser ?

- Vous avez un ton condescendant, c’est pas bien.

La condescendance, c’est un mot qui a le vent en poupe en ce moment. C’est comme l’arrogance. On nous les sert à toutes les sauces. Je suis pris de sympathie et je laisse passer deux personnes. À moins que ce soit la peur ?

Les vendeurs qui sortent à la porte pour faire entrer les clients un par un, m’invitent à entrer.

- Non il n’y a pas de liste Monsieur. Vous avez bien fait de rester.

J’ai acheté une Mercury, la Moon n’étant apparemment pas disponible. Les responsables de la boutique se sont excusés pour l’expérience client. Je les ai sentis désemparés, comme abandonnés par leur entreprise.

La chasse aux collab’

La collection SwatchXOmega remporte un franc succès. Le marketing a été rondement mené. Comme toutes les collaborations, le but est d’étendre le cercle des acheteurs à une population plus large, plus frénétique. Et Swatch a su la trouver auprès d’un public conquis, prêt à acheter ses montres.

Qui n’a pas envie de s’offrir une Omega pour (trois fois) le prix (et la qualité) d’une Swatch ? Reste à savoir si l’opposé est vrai. Ah mais c’est vrai, Omega appartient au groupe Swatch…

Le seul hic c’est qu’il faut entretenir la hype, donner une raison d’être fier de son acquisition, de poster des vidéos et des photos sur les réseaux sociaux. La satisfaction d’être acquéreur se mesure en nombre de likes de nos jours. La stratégie numéro 1 pour ces collab’, c’est de produire en nombre limité. Ca fait des files d’attente monstres qu’on peut filmer en accéléré et poster sur Insta.

Ca fait aussi monter les prix à la revente, ça contribue à l’imaginaire collectif en faisant croire que ces montres en valent le prix. Mais en valent-elles la peine ? Pas vraiment car payer ces prix, c’est aussi pour ne pas avoir à faire des queues interminables où il faut lutter pour avoir une place, sans savoir si les pièces mises en vente seront en nombre suffisant ou si la boutique sera sommée de fermer ses portes pour cause de troubles à l’ordre public.

600 euros, c’est le prix moyen à la revente. C’est 350 euros de bénéf net. Si on se poste à 5 heures du matin et que la vente commence à 10 heures c’est 7 fois le smic horaire. Voire même 10, si ça part à 800 euros. On est 10 fois au-dessus d’une Swatch classique.

Les prix des modèles les plus recherchés comme la Mission to the Moon ont déjà perdu un tiers de leur valeur à la revente. Reste à savoir si les attroupements de revendeurs aux portes des boutiques suivront la même tendance.

DNS message compression refers to a technique used to remove redundant information from its messages. This technique works by replacing duplicated names in a DNS message with a two-byte value indicating the location of their first occurrence. Given that a domain name can be up to 253-byte long, DNS compression reduces substantially the length of DNS messages.

In this article, I present how DNS message compression works. I also provide a concrete example.

DNS Database and Resource Records

DNS refers to a distributed database maintained across multiple DNS servers including the Root, the TLD, and the Authoritative servers.

The DNS database consists of records called Resource Records (RRs) of different types. The most common types of RRs include:

• Type A records contain the IPv4 address corresponding to a domain name.
• Type AAAA records contain the IPv6 address corresponding to a domain name.
• Type CNAME records contain the canonical name corresponding to a domain name acting as an alias.
• Type NS records contain the authoritative server in charge of a domain name.
• Type MX records contain the name of the incoming mail server for a domain.

DNS clients send a DNS query message to fetch one of these RRs for a given domain name. To do so, a client encapsulates a DNS query in a UDP datagram submitted to the local DNS server. In case of a recursive query, the client will wait and receive the DNS answer message eventually.

DNS Messages

A DNS message contains a header followed by the following four (4) different types of sections (some may be empty):

• Questions
• Answers
• Authority
• Additional

Each of these four (4) sections contains 0 or more resource records.

The header consists of the following six (6) fields:

• Identification
• Control
• Number of Questions
• Number of Answers
• Number of Authority
• Number of Additional

The four (4) last fields named “Number of …” indicate the number of resource records contained in the corresponding four sections following the header.

The records listed in the Question section are incomplete whereas the other 3 sections contain complete resource records. The format of a Question record contains the following fields:

{QNAME, QTYPE, QCLASS}

where:

• QNAME refers to the name of the requested resource,
• QTYPE (16) refers to the type of the resource record (i.e., A, AAAA, CNAME, MX, …),
• QCLASS (16) is set to IN (0x0001) for Internet.

The records listed in the Answer, the Authority, and the Additional sections are complete resource records. They correspond to the resource records as stored in the DNS distributed database. The format of a resource record contains the following fields:

{NAME, TYPE, CLASS, TTL, RDATA_LENGTH, RDATA}

where:

• NAME refers to the queried domain name,
• TYPE (16) refers to the type of the resource record (i.e., A, AAAA, CNAME, MX, …),
• CLASS (16) is set to IN (0x0001) for Internet,
• TTL (32) is the duration in seconds during which the resource records will remain valid,
• RDATA_LENGTH (16) refers to the length of the RDATA field,
• RDATA is the data contained in this resource record.

The data in a resource record depends on the type of the resource record:

• For Type=A (0x0001), data is an IPv4 address.
• For Type=AAAA (0x001C), data is an IPv6 address.
• For Type=CNAME (0x0005), data is the canonical name.
• For Type=NS (0x0002), data is the name of the authoritative server.
• For Type=MX (0x000F), data is the name of a mail server.

Due to the many records listed in the 4 sections of a DNS message, a single DNS message may contain multiple names. The same name or a fraction of a name may be duplicated across the multiple records present in the message. Recall that the labels located at the end of a domain name is the name of the parent domains. These repetitions may lead to long messages which waste bandwidth unnecessarily.

DNS Message Compression

A technique called message compression is used to reduce the length of DNS messages by removing duplicated information. This technique targets the names contained in the records carried in the four sections of a DNS message.

According to the DNS message compression technique, a name can be provided either as a sequence of data labels, as a compression label, or as a mix of data and compression labels.

• A data label starts with one byte indicating the length in bytes of the label. The last label of a name is followed by the null label 0x00.

Example: Data label ‘fr’ is encoded by value 0x02667200 where 0x02 is the length of the label (2 characters) and 0x6672 the ASCII codes in hex for characters ‘f’ (0x66) and ‘r’ (0x72). 0x00 is the ending label since ‘fr’ is a TLD domain.

• A compression label refers to a 2-byte label which points to one or many consecutive data labels located above in the DNS message. Instead of repeating the same data label(s), a compression label indicates where to find the data label(s) to be reused. A compression label is 2-byte (e.g., 16-bit) long: The value of the first two bits are set to 0b11 and the remaining 14 bits indicates the offset of the data label(s) to be reused in the DNS message.

Example: 0xC010 indicates that this is a compression label and the data label(s) to be reused is (are) located 16 (0x0010) bytes from the start of the DNS message. All labels, if many, will be read starting from byte 16 until the ending label 0x00.

An Illustrative Example of DNS Compression

The following figure shows the DNS answer message received in response to a DNS query for name “www.upmc.fr”.

The values for the header fields of this message are:

• Identification: 0x37E5
• Control: 0x8180
• Number of questions: 0x0001
• Number of answers: 0x0002
• Number of authority: 0x0000
• Number of additional: 0x0000

The header is followed by the 2 non-empty sections Question and Answers.

The Question section contains one question record:

{NAME=www.upmc.fr, TYPE=1 (A), CLASS=1 (IN)}

The Answer section contains 2 resource records:

• Resource Record 1: Type CNAME

{NAME=www.upmc.fr, TYPE=5 (CNAME), CLASS=1 (IN), TTL=30 (seconds), RDLENGTH=6 (bytes), CNAME=web.upmc.fr}

• Resource Record 2: Type A

{NAME=web.upmc.fr, TYPE=1 (A), CLASS=IN (1), TTL=30 (seconds), RDLENGTH=4 (bytes), RDATA=134.157.250.59}

The DNS answer message contains 4 names listed below by order of appearance:

• Name 1: www.upmc.fr (3 data labels)
• Name 2: www.upmc.fr (1 compression label)
• Name 3: web.upmc.fr (1 data label, 1 compression label)
• Name 4: web.upmc.fr (1 compression label)

In the following table, each row represents a data label or a compression label. The value of each column varies depending on whether the row represents a data label or a compression label.

For a data label:

• Column 1: The length of the label,
• Column 2: The value of the label in hexadecimal,
• Column 3: The value of the data label in plain characters.

For a compression label:

• Column 1: The value of the compression label in hexadecimal,
• Column 2: The value of the offset in decimal,
• Column 3: The value of the data labels (in plain characters) that have been compressed.

After compression, the DNS message is 63 byte long. With no compression, the DNS message would have been 92-byte long:

name 1: 13 bytes (www.upmc.fr)

name 2: 13 bytes instead of 2 bytes (www.upmc.fr)

name 3: 13 bytes instead of 6 bytes (web.upmc.fr)

name 4: 13 bytes instead of 2 bytes (web.upmc.fr)

63-(2+6+2)+3*13 = 92 bytes.

The compression ratio for the DNS message in this example is 31.52%.

Let’s now consider the following trace representing the answer of the DNS request for lip6.fr's authoritative servers (nslookup -type=NS lip6.fr).

What is the compression ratio for this message? Detailed answer here.

Final Word

Techniques such as DNS message compression are of paramount importance for the Internet of Things and the integration of low-powered wireless devices as these techniques lower the size of IPv6 packets to match small MTUs. DNS message compression exploits the hierarchical nature of domain names. This technique works by removing the duplicated names and the labels shared between names belonging to domains under the same parent domain.

Dans cet article, j’introduis les notions et concepts nécessaires à la compréhension d’Internet et aux réseaux de données en général.

Cet article est basé sur le chapitre de mon ouvrage intitulé “Technologies et protocoles Internet” publié dans la collection Références sciences des éditions Ellipses.

Cet article concentre en grande partie sur les notes de cours de l’unité d’enseignement LU3IN033 que Promethee Spathis enseigne à Sorbonne Université et que vous pouvez visionner sur YouTube.

Les données, d’où viennent-elles et pourquoi les transporter ?

Les données font référence aux bits que génèrent les applications exécutées à l’initiative des utilisateurs sur leur ordinateur. Des exemples d’applications sont les navigateurs Web, les clients mail ou un client BitTorrent. Toutes ces applications sont des programmes qui communiquent avec un programme homologue, exécuté sur une machine distante.

Modèle client-serveur

Originellement, ces deux programmes étaient conçus de manière asymétrique : le programme distant diffère de celui exécuté sur l’ordinateur des utilisateurs. En tant qu’utilisateurs, nous nous connectons à un réseau de données en vue de recevoir une page web, des images, un email ou une vidéo. Ces objets sont hébergés sur des machines appelées serveurs. Nous sommes les clients de ces machines qui, du fait de répondre à nos requêtes, sont appelées serveurs.

Les serveurs offrent des capacités de stockage qui leur permettent d’héberger des contenus accessibles à tous. Les serveurs disposent également de capacités de traitement qui leur permettent de traiter les requêtes de leurs clients.

Modèle pair-à-pair

Récemment, on a vu l’avènement d’un nouveau type d’applications résultant de l’exécution de programmes identiques. On parle d’applications pair-à-pair où une même machine peut agir aussi bien en tant que client que serveur.

Interopérabilité

Applications client-serveur ou pair-à-pair sont mises à disposition au téléchargement par leurs développeurs. Les utilisateurs sont libres d’installer ces applications sur leur ordinateur. Il n’y a pas, à proprement parler, de réel contrôle concernant les applications qu’un utilisateur peut installer sur son ordinateur.

Qu’ils s’agissent des constructeurs de matériel informatique ou des concepteurs de systèmes d’exploitation qui équipent nos ordinateurs à leur achat, tous œuvrent dans le but de concevoir des équipements ouverts et interopérables qui rendent leurs produits attractifs du fait de leur versatilité. C’est ce qui a fait le succès de l’Internet.

L’utilisation de certains logiciels peut être restreinte. Un fournisseur d’accès Internet (FAI) peut éventuellement être soumis aux lois nationales contre le piratage informatique ou la violation des droits d’auteur par exemple. Pour autant, les FAI ne sont pas toujours en mesure de filtrer avec succès les trafics dérogeant à ces lois.

Comment les données sont-elles ‘emballées’ en vue de leur transport ?

A la manière des produits ou denrées transportés par un transporteur tel que Colissimo ou UPS, les données ont besoin d’être emballées.

Fragmentation

Dans un réseau de données, les données sont fragmentées : une longue série de bits de données appartenant à un même fichier est répartie dans plusieurs colis appelés messages.

Encapsulation et désencapsulation

L’équivalent des cartons d’emballage sont des bits supplémentaires ajoutés généralement en tête des bits de données appelés de ce fait, entête. A la manière des dimensions ou du poids d’un colis, la longueur des messages exprimée en nombre de bits est soumise à des restrictions qui imposent une longueur minimale et maximale. L’ajout d’un entête est appelé encapsulation et le retrait de l’entête désencapsulation.

Entête et charge utile

Dans un réseau de données, un colis est donc un message constitué d’un entête et des bits de données. Les bits de données forment le corps du message que l’on appelle aussi charge utile du message. Les messages ayant une longueur maximale, plusieurs messages sont nécessaires pour transmettre un même objet telle qu’une image.

Dans l’entête d’un message, on retrouve des bits appelés informations de contrôle telles que l’adresse du destinataire et celle de l’expéditeur. A la manière du papier-bulle utilisé pour éviter la casse des produits fragiles, l’entête peut également contenir des bits appelés somme de contrôle permettant de détecter les bits reçus en erreur. Une fois détectées, on peut réparer les erreurs en retransmettant les messages erronés.

Les bits correspondant aux adresses ou la somme de contrôle sont des exemples de champs. Un entête est une succession de champs dont la longueur est variable ou fixe. La structure d’un entête aussi appelé format d’un entête fait référence aux champs qui composent cet entête. Pour chaque champ est précisé le nom, la longueur en bits, et sa signification selon la valeur qu’il contient. La valeur d’un champ peut être fournie sous la forme d’un code binaire (la valeur 0x06 fait référence au protocole TCP) ou du code ASCII de la valeur en question (la valeur 0x474554 indique la méthode GET).

Transporter les données avec des garanties

L’entête d’un message étant ajouté dans un but précis, plusieurs entêtes sont nécessaires afin d’assurer les nombreuses propriétés attendues concernant le transport des données.

De telles propriétés comprennent la fiabilité (réception de l’intégralité des données, exemptes d’erreurs), l’efficacité (la quantité des données émises maximise l’utilisation de la capacité du réseau) ou la résistance au facteur d’échelle.

Fiabilité

Des messages pouvant être perdus, reçus en erreur, en désordre ou dupliqués, des bits de contrôle sont inclus dans leur entête. Ces bits font référence à un numéro appelé numéro de séquence qui permet de détecter les messages manquants, de réordonner les messages ou de supprimer les doublons. On trouve également une somme de contrôle dont le rôle est de vérifier si le message contient des bits en erreur. Comme l’indique son nom, son calcul résulte de la somme des bits du message avant son envoi. A sa réception, le destinataire refait le même calcul et vérifie si le résultat coïncide avec la somme calculée par la source.

Efficacité

L’efficacité dans un réseau de données est similaire à celle qu’un transporteur met en œuvre pour s’assurer que ses fourguons sont tous utilisés au maximum de leur capacité de transport. L’efficacité peut également faire référence à la proportion du message occupée par son entête comparée à sa charge utile. Si envoyer un colis est facturé sur la base de son poids brut, l’expéditeur cherchera à minimiser le poids du carton d’emballage. Il en va du même des autoroutes dont le nombre de voies est déterminé de façon à éviter les bouchons mais également leur sous-utilisation. Le coût de réalisation et d’exploitation des autoroutes doit être en adéquation avec leur utilisation, leur financement dépendant des recettes aux péages. On parlera alors d’utilisation efficace des autoroutes. De la même manière, les coûts liés au déploiement et à la maintenance d’un réseau de données ainsi que sa capacité doivent être en adéquation avec le volume des données transportées, le nombre d’utilisateurs et le prix d’un abonnement Internet.

Résistance au facteur d’échelle

Une autre propriété est la résistance au facteur d’échelle (ou scalabilité). Il s’agit d’un principe de conception qui caractérise un système dont les performances ne sont pas, ou sont peu sensibles à une grandeur dénombrable croissante, caractérisant ce système. Cette grandeur peut faire référence au nombre d’utilisateurs ou de nœuds dans un réseau. Une autre grandeur peut aussi faire référence au nombre de messages en transit dans le réseau ou de requêtes que reçoit un serveur. Un transporteur de colis doit s’assurer du bon déroulement de ses opérations, y compris à l’occasion des fêtes de fin d’années.

Dans un réseau de données, pour assurer les nombreuses propriétés attendues concernant la livraison des données, un seul entête ne suffit pas.

Architecture en couches

Un message comprend donc une série d’entêtes ajoutée aux bits de données. Un entête est ajouté dans un but spécifique qui détermine le type d’informations contenues dans cet entête. L’ajout d’un entête se fait en sollicitant un programme qui prend en paramètre les bits de données.

Les bits de données passent par une série de programmes qui se relaient pour ajouter un entête supplémentaire avant que le message final soit prêt à être transmis sur le support de transmission. Le dernier programme à ajouter un entête, ajoute également des bits en fin du message appelés de ce fait enqueue du message.

A la réception du message final, les entêtes sont progressivement retirées en traversant une séquence de programmes similaire à celle traversée avant l’émission de ce message mais en sens inverse. Le dernier entête à avoir été ajouté est le plus externe (situé à gauche) et donc le plus accessible. Chaque programme accède uniquement à l’entête ajouté côté émetteur par son programme homologue.

Couches et protocoles

Dans Internet, les programmes qui contribuent à la préparation des données en vue de leur transmission sont au nombre de 5. En première position, on retrouve les programmes applicatifs qui génèrent les données côté émetteur et les consomment côté récepteur. En dernière position, on retrouve la carte réseau dont les composants matériels transforment le message sous la forme d’un signal émis sur le support de transmission.

Empilement. Par souci de représentation, ces programmes sont empilés les uns sur les autres et la traversée des données se fait de haut en bas côté émetteur et de bas en haut côté récepteur. On parle alors de couches en lieu et place des programmes, une même couche pouvant être implémentée de plusieurs manières différentes selon les propriétés attendues de cette couche.

Protocole. Une couche collabore avec sa couche homologue distante selon des règles bien précises concernant la structure de l’entête qu’elle ajoute et retire aux messages. Ces règles définissent également les actions à exécuter en vue de l’émission ou suite à la réception d’un message. De ces actions peuvent résulter l’installation, la mise à jour ou la suppression d’un état. Un état fait référence à une valeur stockée en mémoire qui caractérise l’état de l’échange entre deux machines. L’ensemble de ces règles forme un protocole. Pour communiquer entre elles, deux machines exécutent simultanément plusieurs protocoles, un par couche.

Standardisation. Certains protocoles ont été standardisés rendant ainsi leurs spécifications accessibles à tous. C’est le cas par exemple de HTTP, le protocole qui régit les communications entre navigateurs et serveurs Web. Les spécifications de HTTP étant publiques, plusieurs navigateurs sont proposés par différentes sociétés telles que Microsoft ou Google. Du fait d’avoir été développés conformément au standard, navigateurs et serveurs savent communiquer entre eux, le logiciel coté serveur étant également conforme au standard.

Entête de protocole. À la manière des étiquettes apposées sur un colis, un protocole ajoute un entête à l’émission d’un message. La position de cet entête est déterminée par la couche à laquelle le protocole appartient. L’entête est ajouté en vue d’être lu par sa couche homologue une fois le message reçu. Ce sont les informations de contrôle contenues dans les champs de cet entête qui permettent de déterminer les actions à entreprendre à la réception du message. Des exemples d’actions inclus l’installation ou la mise à jour d’un état, la génération d’une réponse sous la forme d’un message retourné à la source ou la suppression du message si reçu en erreur par exemple. De l’exécution de ces actions résultera le service attendu de cette couche.

Services de communication. Une même couche pouvant offrir différents types de service, certaines couches implement plusieurs protocoles. C’est le cas de la couche application qui implémente autant de protocoles que d’applications installées sur nos ordinateurs. Un service de communication résulte de l’exécution du protocole spécifique à la couche qui offre ce service.

L’ensemble des couches et des protocoles qu’elles implémentent constitue ce qui est communément appelée une architecture de réseau. Du fait de l’empilement des couches qui implémentent les protocoles, on parle aussi d’architecture en couches.

Internet et modèle OSI

Les composants logiciels et matériels qui permettent aux utilisateurs d’envoyer ou de recevoir des données via les applications qu’ils installent sur leur machine sont donc structurés en couches, au nombre de 5 dans Internet.

Les fonctions prises en charge par chacune de ses couches sont habituellement décrites en faisant référence au modèle OSI (Open Systems Interconnection) normalisé dans les années 1970 par l’ISO (International Organization for Standardization). Le modèle OSI comporte 7 couches identifiées par un numéro et un nom. La numérotation commence à 1 pour la couche la plus basse appelée couche Physique.

Sur les 7 couches du modèle OSI, seules 5 ont été implémentées dans Internet, les fonctions des couches numérotées 5 et 6, appelées Session et Présentation respectivement, étant prises en charge pour certaines par la couche 7. L’ensemble de ces couches et les protocoles qu’elles implémentent forment une architecture de réseau. On parle aussi de pile protocolaire pour faire référence à l’ensemble des protocoles réunis au sein d’une même architecture de réseau.

Couche Application (7)

L’architecture de Internet comprend au niveau le plus élevé la couche 7 appelée couche Application. Les programmes qui implémentent cette couche sont par exemple, les navigateurs Web côté client et les serveurs Web côté serveur. Leur but est d’exécuter le protocole HTTP (Hypertext transfer protocol) qui permet le téléchargement des pages Web.

Les deux couches suivantes nommées couche Transport (couche 4) et couche Réseau (couche 3) sont fournies avec les systèmes d’exploitation installés sur les ordinateurs personnels, les smartphones ou autres objets communicants.

Couche Transport (4)

La couche 4 appelée couche Transport offre deux services résultant de deux protocoles : TCP (Transmission control protocol) et UDP (User datagram protocol).

TCP segmente les données générées par l’application émettrice et ajoute à chaque segment un entête. Le message résultant de cette encapsulation est appelé segment. Dans le cas de UDP, les données générées par l’application ne sont pas segmentées. UDP se contente d’ajouter son entête aux données applicatives. Le message résultant de l‘encapsulation des données applicatives est appelé datagramme. Si la taille du datagramme le requiert, c’est la couche Réseau (3) sous-jacente qui se chargera de sa fragmentation.

C’est la couche Transport qui fournit aux développeurs l’interface de programmation, appelée socket, qui permet de concevoir des applications réseau.

Couche Réseau (3)

La couche 3 appelée couche Réseau implémente le protocole IP (Internet Protocol) qui ajoute à son tour un entête et le message qui en résulte est appelé paquet. Un paquet est donc un segment TCP ou un fragment de datagramme UDP auquel a été ajouté un entête de couche 3. Cet entête contient notamment les adresses source et destination du paquet. La couche 3 a pour rôle l’acheminement des paquets vers leur destination.

Couche Liaison de données (2)

La couche 2 appelée couche Liaison de données est à la fois logicielle et matérielle. La partie logicielle correspond aux pilotes qui permettent d’interagir avec la partie matérielle qui elle, correspond aux cartes réseau telles que Ethernet ou Wifi. La couche Liaison de données a la particularité d’ajouter un entête mais également un enqueue à la suite des bits de données du paquet pour former une trame.

Couche Physique (1)

La partie matérielle comprend également la couche 1 appelée couche Physique. Elle est responsable de la conversion des bits sous la forme d’un signal adapté aux supports de transmission. Dans l’architecture Internet, les couches 1 et 2 forment un tout dénommé interface réseau que l’on désigne usuellement par l’identifiant eth0 dans le cas des cartes Ethernet ou Wifi.

Les couches 1 et 2 dépendent des caractéristiques physiques du support de communication et du nombre de machines connectées à ce support.

Cœur vs. périphérie du réseau

Dans Internet, la pile TCP/IP fait référence aux deux protocoles implémentés respectivement par la couche Transport (4) et Réseau (3). Pour comprendre le rôle des couches 4 et 3 dans Internet, il est nécessaire de présenter les deux types de machines que l’on trouve dans les réseaux de données. Ces deux types de machines différent selon :

1. leur position dans le réseau et
2. les fonctions qui leur incombent.

Machines hôtes vs. routeurs

Machines hôtes. Le premier type de machines sont les ordinateurs personnels, tablettes, smartphones et autres dispositifs que nous utilisons pour accéder à Internet. Ces machines sont les seules où peuvent être installées et exécutées les applications dans un réseau. Du fait d’héberger les applications, ces machines sont appelées machines hôtes. Elles forment la périphérie du réseau où les données sont générées et consommées. Les machines hôtes sont donc situées aux extrémités des communications.

Routeurs. Le second type de machines sont les noeuds internes du réseau appelés routeurs. Ces derniers sont reliés entre eux par des liens selon une configuration formant un maillage partiel. Les routeurs et les liens les reliant forment ce qu’on appelle le cœur du réseau en opposition à la périphérie du réseau où se retrouvent les machines hôtes. Cette interconnexion de routeurs permet de minimiser le nombre de liens nécessaires pour connecter les machines hôtes entre elles.

Parmi l’ensemble des routeurs, on distingue ceux situés en bordure du cœur auxquels se connectent les machines hôtes pour accéder au réseau. Ces routeurs sont de ce fait dénommés routeurs d’accès. Les machines hôtes accèdent à Internet en contactant un premier routeur qui agit comme la passerelle par défaut appelée en anglais default gateway. Les machines hôtes qui utilisent les services d’une même passerelle sont connectées à un même réseau physique appelé réseau local.

Le rôle des routeurs découle de la topologie du réseau de cœur. Le maillage partiel entraîne l’existence de plusieurs chemins alternatifs entre paires de machines hôtes. Il est donc nécessaire pour chaque destination de sélectionner un chemin unique, le long duquel seront acheminés invariablement les messages tant que ce chemin reste disponible. Nous verrons que cette constance dans le choix du chemin emprunté par l’ensemble des messages pour une même destination est primordial pour la réparation efficace de leur perte.

Routage vs. acheminement

Le rôle d’un routeur est donc double. Le premier est l’acheminement des données, le second est le routage (ou sélection de chemins). Un routeur achemine les messages en les transmettant sur le lien de sortie qui les rapprochera de leur destination finale. Ce lien de sortie permet de joindre un nœud voisin appelé saut suivant. Le choix du saut suivant résulte d’un algorithme de routage dont l’objectif est de choisir un chemin pour chaque destination du réseau.

Algorithme de routage. Pour ce faire, certains algorithmes de routage calculent le chemin le plus court, la distance des chemins pouvant faire référence au nombre de routeurs qu’ils les constituent par exemple. C’est le cas de l’algorithme de Bellman-Ford. Si les liens sont configurés avec un coût, le chemin choisi est alors celui dont la somme des coûts des liens qui le constituent, est la plus petite. C’est le cas de l’algorithme de Dijkstra. D’autres algorithmes considèrent les accords commerciaux entre FAI (Fournisseurs d’accès Internet) qui collaborent pour acheminer les données sur des distances couvrant des zones géographiques étendues telles que des pays ou des continents.

Protocole de routage. Pour s’exécuter, ces algorithmes ont besoin de connaître la topologie partielle ou complète du réseau. Les routeurs la découvrent en exécutant un protocole de routage implémenté par la couche Réseau (3) des routeurs. Un protocole de routage permet aux routeurs de collaborer en échangeant des messages contenant des informations sur la topologie du réseau et selon les règles définies par le protocole de routage. Des exemples de protocole de routage sont RIP (Routing information protocol), OSPF (Open shortest path first) ou BGP (border gateway protocol).

Adressage. Pour calculer les chemins, les routeurs doivent connaître la position des nœuds au sein de la topologie du réseau. Pour ce faire, une valeur unique appelée adresse est attribuée à chacun des nœuds. Dans le cas de Internet, cette adresse est une valeur binaire longue de 32 bits appelée adresse IP. Les adresses IP sont présentées au format décimal pointé : les quatre octets qui les forment sont convertis en décimal et les valeurs décimales résultant de cette conversion séparées par un point.

A la manière des numéros de téléphone, les adresses IP sont attribuées hiérarchiquement par les fournisseurs Internet. Tout comme les indicatifs téléphoniques qui identifient une zone géographique, les premiers bits d’une adresse identifient le réseau auquel est connecté la machine à qui appartient l’adresse. Ces bits appelés préfixe réseau ont une longueur variable déterminée par le nombre de bits positionnés à 1 dans une adresse particulière appelée masque de réseau, défini pour tout réseau.

Nous verrons par la suite que les machines sont identifiées par une seconde adresse appelée adresse MAC, gérée par la couche Liaison de données.

Plan de données vs plan de contrôle. L’acheminement des données et la sélection des chemins qu’empruntent les données sont des fonctions réalisées par la couche Réseau (3). Les fonctions nécessaires à l’acheminement des données font partie du plan de données et celles nécessaires à la sélection des chemins font partie du plan de contrôle des routeurs.

Plan de gestion. En plus des plans de données et de contrôle, on trouve le plan de gestion qui réunit les fonctions nécessaires à la configuration et la supervision des plan de données et de contrôle des routeurs. C’est du plan de gestion que résulte par exemple la configuration du coût des liens nécessaire au protocole OSPF. Si les plans de données et de contrôle sont automatisés, le plan de gestion lui nécessite l’intervention manuelle d’un administrateur.

L’ensemble des autres fonctions nécessaires à la livraison des données sont prises en charge par les machines hôtes. Ces fonctions sont réalisées par la couche Transport, numérotée 4. Elles répondent aux besoins des applications qui s’exécutent au niveau 7. Ces fonctions incluent la fiabilisation des messages ou l’utilisation efficace et équitable de la bande passante du réseau.

Fiabilisation. Au cours de leur acheminement, des messages peuvent être perdus ou reçus en erreur. Dans l’architecture Internet, la correction des pertes de messages et des messages en erreur est à la charge de la couche Transport (4). Ces pertes pouvant résulter de l’absence de ressources nécessaires pour traiter les messages si en surnombre, il est nécessaire d’ajuster le débit d’émission des sources de façon à éviter les pertes qui pourraient s’ensuivre. Cet ajustement se fait équitablement parmi l’ensemble des sources dont les messages empruntent le même chemin. La bande passante utilisée par chacune de ces sources est répartie équitablement.

La couche Réseau (3) se retrouve sur l’ensemble des machines de l’Internet y compris les machines hôtes, ces dernières étant responsables de définir les adresses IP source et destination des paquets. La couche Transport (4), quant à elle, est présente uniquement sur les machines hôtes. Ce choix résulte d’un principe de conception appelé le principe du bout en bout.

Principe de bout en bout

Le principe de bout en bout exerce une force centrifuge sur les fonctions nécessaires à la livraison des données. Lorsque le choix est donné de concevoir une fonction en faisant intervenir, soit toutes les machines du réseau y compris les routeurs, ou uniquement les machines hôtes de la périphérie, il est recommandé de privilégier en priorité la seconde solution.

La logique du principe de bout en bout est d’éviter l’exécution répétée d’une même fonction sur l’ensemble des routeurs situés le long du chemin que traverse un message. Dans le cas de l’Internet, la longueur d’un chemin alterne en moyenne entre 15 et 20 sauts. En cantonnant l’installation d’une fonction uniquement aux extrémités, cette même fonction est exécutée deux fois. C’est le cas des fonctions nécessaires à la réparation d’un message en erreur ou perdu.

Fiabilisation de bout en bout

Dans Internet, la détection des messages en erreur résulte de l’utilisation d’une somme de contrôle qui permet au récepteur de détecter les messages contenant des bits de données en erreur. Ces erreurs peuvent intervenir plus en amont le long du chemin mais ce n’est qu’une fois le message acheminé jusqu’à sa destination finale qu’il sera rejeté par le récepteur qui prétendra ainsi ne pas l’avoir reçu.

L’absence d’accusé de réception provoquera l’expiration d’un temporisateur armé par la source à l’émission du message et la retransmission du message. La valeur du temporisateur de retransmission est calculée de façon à refléter la durée d’un aller-retour entre source et récepteur du message. Pour garantir la validité de cette valeur, il est nécessaire de préserver la longueur du chemin entre source et récepteur. De ce fait, l’acheminement des paquets dans Internet se fait le long d’un chemin unique qui ne changera qu’en cas de défaillance.

En limitant l’exécution de ces fonctions aux seules extrémités, on retarde la réparation d’un message en erreur. Ce retard est cependant acceptable en comparaison au délai et à la charge qu’aurait induit l’exécution d’une fonction similaire mais implémentée sur l’ensemble des routeurs du réseau.

Serveurs proxy

Il en va de même pour la plupart des fonctions nécessaires à la livraison des données. Cependant, des exceptions existent, notamment sous la forme des serveurs dits mandataires, appelés proxy servers en anglais. Un proxy est un équipement installé le long des chemins entre clients et serveurs. Leur rôle est d’intercepter les requêtes des clients et de se substituer, lorsque possible, aux serveurs. C’est le cas des caches Web qui stockent temporairement les pages Web les plus populaires afin d’accélérer leur livraison, les caches Web étant situés au plus prêt des clients comparés aux serveurs auxquels ils se substituent. Les caches Web assurent des fonctions applicatives censées être cantonnées à la périphérie du réseau. C’est dans ce sens que les proxys font exception au principe de bout en bout.

Mode datagramme vs mode circuit virtuel

Il existe d’autres architectures de réseau qui, contrairement à Internet, ont fait le choix d’impliquer les nœuds internes de leur réseau dans la fiabilisation des messages échangés. C’est le cas de Transpac par exemple dont les nœuds internes appelés commutateurs réservent préalablement les ressources nécessaires à l’acheminement des messages en vue d’éviter leurs pertes, faute de ressources. Ces ressources sont réservées au niveau des commutateurs situés le long du chemin qu’emprunteront par la suite les messages et ce, invariablement. L’ensemble des ressources réservées forme une connexion et le chemin, un circuit virtuel. On parle de service en mode circuit virtuel. Une rupture de lien ou la perte d’un des commutateurs situés le long d’un circuit virtuel entraîne l’interruption de la communication. Pour la rétablir, une nouvelle connexion est nécessaire.

Les mécanismes de réservation de ressources complexifient le fonctionnement des commutateurs et inexorablement, leur coût. Ce choix de conception n’a pas été suivi dans Internet. Le chemin n’étant pas fixé au préalable, on parle de service en mode datagramme. Un datagramme suit un chemin sans la garantie que les ressources nécessaires à son acheminement soient présentes. L’absence de ressources suffisantes fait référence à la congestion qui provoque la destruction des datagrammes en excès. Dans Internet, les datagrammes font référence aux paquets IP qu’on appelle aussi de ce fait, datagramme IP.

Moodle as many other learning managing systems allows instructors to design online assessments. In Moodle, online assessments are called quizzes. Quizzes can be used to administer tests, assignments, quizzes, or exams.

A quiz consists of questions you can either create from scratch or select from the question bank. You can also let Moodle randomly select previously created questions from the question bank.

Moodle offers a wide variety of question types. Multiple choice, true-false, and matching questions are the most common type of question as they are thought to be the only questions that can be graded automatically. However, other question types such as Fill in the blank questions can also be graded automatically while offering greater flexibility. In Moodle, Fill in the blank questions are called Embedded-Answers or Cloze questions.

In this article, I present how to write effective Fill in the blank (aka Embedded-Answers) Questions with Moodle. You can also download the cheat sheet for Embedded-Answers Questions at bit.ly/moodle-cloze.

• I first introduce the four (4) main types of Embedded-answers questions.
• I then present the Moodle text editor and the markup language for writing Embedded-answers.
• I show the various feedback that students will receive after answering an embedded-answers question.
• I give a handful number of tips to consider when developing embedded-answers questions.
• Finally, I conclude this article with an example of quiz I give to the undergraduates who take my introductory course to Computer Networking at NYU Shanghai and Sorbonne Université.

The 4 Types of Embedded-Answers Questions

Moodle Embedded-Answers questions are similar to Fill in the Blank questions on Sakai and other LMSes. There are four (4) main types of embedded-answers questions:

• Short Answer;
• Numerical;
• Multi-Choice;
• Multi-Response.

Below I present a preview of each type of embedded-answers questions.

For instance, when students encounter a Short Answer (Question 1 in the above figure) or a Numerical question (Question 7 in the above figure), they are presented with a text box in which they can enter their answer. Their answers will be compared to a list of predetermined answers provided during the authoring of the question. All predetermined answers come with the number of points they are worth. You can update the list of predefined answers and/or their points after the quiz due date and ask Moodle to regrade all student attempts.

Moodle Text Editor

To create an embedded-answers question, Moodle will present you with a page comprised of two text areas. The first text area is a text editor where you will add the text of your question and the markup text for the answers. The second text area is where you can optionally add the general feedback students will see after submitting their answers.

The top of the question text editor is a toolbar with a list of icons to create headings, bold or italic text, color and highlight text, create numbered and bulleted lists, or adding media or links to a page.

By default, the toolbar is collapsed with only one row of the most commonly used tools showing. The default toolbar can be expanded to show all of its features by clicking the “Show/hide advanced buttons” button (e.g., the first on the left of the collapsed toolbar).

Contrary to the question itself which can be specified in a WYSIWYG way, the embedded-answers follow a WYSIWYM (What you see is what you mean) approach. You need to follow a strict syntax for Moodle to understand how to grade the question. I will present the syntax of Moodle markup language in the next section.

Once you have entered your question into the first text area, you can see a preview of your question: Click “Save changes and continue editing”; A clickable magnifying glass icon will appear followed by “Preview”. A pop-up window will show a preview of the question you are authoring. The bottom of the window will give the following choices:

“Fill in correct answers” will let you preview the correct answers you have programmed. You can also fill arbitrary answers and check how Moodle will grade the question after clicking “Submit and finish”.

Below, I show on the left, the markup text of two Short Answer subquestions and on the right, the resulting output the students will see. This question consists of two subquestions, each followed by the expected embedded-answer. You can add as many embedded-answers as subquestions in the main question you are creating.

The Embedded-Answers Markup Language

The minimal syntax of an embedded-answer is the following:

{:SA:=Correct Answer}

This corresponds to an embedded-answer accepting a single correct answer with no specific feedback. The maximum score will be awarded only if students give the answer “Correct Answer”. Any extra space or spelling mistakes will be counted as wrong.

The full syntax of an embedded-answer is the following:

An embedded-answer is delimited by an opening and a closing curly bracket ‘{’ … ‘}’. Inside the brackets there are four parts, the first and last being optional:

• The first part is a strictly positive integer (1, 2, 3, etc.) that indicates the weight of the answer. This weight is used in the calculation of the overall question grade. In case of a question with multiple subquestions, the total points for the question will be computed as the weighted sum of all subquestion points using the weight assigned to each subquestion. If all subquestions have the same weight, this first part may be skipped.
• The second part is delimited by semicolons (‘:’) and indicates the type of the embedded-answer (SA, NM, MC, MCH, MCV, MR, and MRH).
• The third part gives the predefined answer(s) against which students’ answers will be matched. Each answer is preceded by its score given as a percentage of the total score awarded for the correct answer. Consecutive predefined answers are separated by the tilde symbol (‘~’). A correct answer is preceded by the equal sign (‘=’) or by ‘%100%’. This will indicate that the corresponding answer will be awarded the maximum score. A partially correct answer is typically preceded by a value greater than 0 but lower than 100 (e.g. ‘%50%’). The wildcard character (‘*’) can be used as a catch-all for all wrong answers. If wrong answers are awarded zero points, ‘ ~%0%*’ is optional. You can also award a negative score in case of any wrong answer (e.g. ‘%-50%*’).
• The fourth and last part is optional. It indicates the specific feedback students will receive if enabled in the Quiz settings. The hash symbol (‘#’) that follows a predefined answer indicates the specific feedback the students who gave that answer will receive.

Short Answer Questions

The table below presents various combinations of correct, partially correct, and incorrect answers and specific feedback with the corresponding Moodle markup text.

Below, I explain the syntax of Moodle’s markup text for each type of answers and feedback listed in the previous table.

One correct answer:

{1:SA:=correct answer}

where ‘=’ marks the correct answer.

Multiple correct answers:

{1:SA:%100%correct answer 1~%100%correct answer 2}

where ‘~’ is the separator between each answer and %100% the percentage of the subquestion total points for the corresponding answer. Any other answer than ‘correct answer 1’ and ‘correct answer 2’ will be considered wrong and awarded 0 points.

Correct and partially correct answers with specific feedback:

{1:SA:%100%answer1#Correct~%50%answer2#Partially correct}

where ‘#’ marks the beginning of a specific feedback for the preceding answer. Specific feedback are shown to students if opt-in in the Review options of the quiz. Any other answer than ‘answer1’ and ‘answer2’ will be considered wrong and awarded 0 points.

Correct, Partially correct, and incorrect answers with specific feedback:

{1:SA:%100%answer1#Correct~%50%answer2#Partially correct~%-50%*#Wrong answer}

where ‘*#’ indicates the feedback students will receive in case of any answer other than the preceding listed answers. %-50% indicates that half of the points allotted to the subquestion will be deducted from the overall question score if the student selects any answer other that the correct and the partially correct answers.

Embedded-Answers Questions

The table below lists all types of embedded answers:

Below, I give the Moodle markup text for each type of embedded-answers and the preview of the question:

Embedded-Answers Tips and Considerations

Adjusting the Layout of Embedded-Answer Questions

The length of the text box in SA and NM embedded-answers is computed based on the length of the longest answer including the wrong answers.

In case of multiple SA or NM subquestions, the trick to fix the length of all the text boxes is to add the same dummy wrong answer to all embedded-answers.

In the example below, I’ve added the dummy wrong answer ‘~%0%XXXX’. I also show the use of tables for a better control over the alignment of the subquestions and the corresponding answer boxes.

You can also control the size and the borders of the table, by tweaking the HTML code of the question. Click the last icon in the text editor extended toolbar (</>) to show the HTML code for the question you are authoring:

• To extend the width of the table, add tag width followed by the size in pixels (i.e., “500”).
• To enable borders, add tag border followed by the thickness of the border lines in pixels (i.e., “1”).

The HTML code should look like this:

<table width="500" border="1">

Use Keyword ‘Empty’ for Questions with Non-Applicable Answers

Student answers are matched against the list of expected answers embedded in the Cloze question. To grade a question, Moodle expects to find an answer. A question submitted with no answer is considered as not answered and won’t be awarded any points.

To indicate to Moodle that the blank answer is a correct answer, you can define the use of a specific keyword such as ‘empty’ that Moodle will interpret as a blank answer. The points for this question will be awarded if ‘empty’ has been answered.

Avoid Copy/Paste from MS Word

If you copy the answers from a Microsoft Word document, this may add some unwanted code to the HTML code that Moodle will consider as part of the answer. As students fill their answer in plain text, Moodle may flag their answer as wrong because of the code wrongly added to your embedded-answer. To avoid having to clean the html code of your question, use a plain text editor.

Keep Questions Short and Add Break Pages

Once a question answered, there are two main ways for Moodle to store the answers. Students can either click “Submit all and Finish” or navigate within the quiz provided that questions are distributed on multiple pages. In the latter, Moodle will log the answers until submission. Depending on the Time setting of the quiz, answers can be submitted either automatically upon expiration of the quiz time limit or only if students click “Submit all and Finish” before the closing date of the quiz.

In the layout quiz settings, you can ask Moodle to put one question per page. You can also add page breaks where needed in the ‘Edit quiz’ page. Adding page breaks will let Moodle log the answers as students navigate through the pages of the quiz.

Regrade a Quiz after its Closing Date

You can make changes to the quiz and have Moodle regrade all attempts. Such changes include changing the maximum points of a specific question or the maximum grade of the quiz. You can also add answer options to Short Answers and Numerical questions.

From the Quiz summary page, you can access the attempts summary page where a table will list all attempts and for each attempt, the detailed points awarded per question. You can review how the students performed for each question of the quiz.

If after reviewing student answers, you realize that a handful number of students responded with a partially correct answer you didn’t anticipate when creating the quiz, you can add that answer in the answer options of the embedded question. You can then have all attempts regraded to account for that additional answer.

Review Options

In the table below, I present what the student sees after answering an embedded-answers question depending on the review options of the quiz. In this example, the question has the two following subquestions:

Subquestion 1: {1:SA:=Correct answer 1#Correct Answer!~%0%*#Wrong Answer!}

Subquestion 2: {1:SA:=Correct answer 2#Correct Answer!~%0%*#Wrong Answer!}

Students who enter the correct answer will receive feedback ‘Correct Answer!’ and feedback ‘Wrong Answer!’, otherwise.

For each example, I suppose that a student has answered the first subquestion with the correct answer (e.g., “Correct answer 1”) and the second with a wrong answer (e.g., “Wrong answer 2”).

In the left column, I show the Review options you can set in the Quiz settings and in the right column, the resulting output as seen by the students. These outputs are similar whether the review options are set to ‘During the attempt’, ‘Immediately after the attempt’, ‘Later, while the quiz is still open’, or ‘After the quiz is closed’. The only difference is when the various feedback will be available for review to the students.

The points awarded for the question (e.g., mark), whether the answer is correct or not, the specific feedback for the provided answer, and the right answer are shown in a yellow box revealed when passing the mouse over each answer. The general feedback is shown below the question in an orange text box.

A Comprehensive Example

To show the range of possibilities embedded-answers questions can offer, I present a quiz I give in my introductory course to Computer Networking. The topics covered by this assessment include IP subnetting, ARP, ICMP, and Proxy ARP.

You can download this quiz in Moodle XML format here (right-click and select ‘Save link as’) and import the quiz in your course question bank.

Part 1

Consider the network depicted in Figure 1. This network consists of two (2) Ethernet segments interconnected by a bridge noted X.

A, B, C, and D are end hosts. The IP and MAC addresses are shown in the figure. The figure also shows two observation points which capture the traffic on both directions on each segment.

Host A (172.16.10.100) wants to ping host D (172.16.20.200). The following command is run on Host A:

ping –c 1 172.16.20.200

Question 1.1

Host A starts by sending an ARP request. Complete Table 1.1 with the MAC addresses found in the Ethernet frame header encapsulating the ARP request and the ARP reply messages as captured at each Observation Point.

Question 1.2

Complete Table 1.2 with the addresses found inside the ARP messages captured by Observation Points 1 and 2.

Question 1.3

Host A can now send its Echo Request to host D. Complete Table 1.3 with the addresses included in the Ethernet and IP headers of the Echo Request and the Echo Reply captured at Observation Point 1.

Question 1.4

Suppose host A has sent pings to all other machines in this network. Complete Table 1.4 with the entries that can be found in host A’s ARP table. Use keyword empty for cells with no applicable value.

Part 2

Consider now that the two segments are connected by a router noted R. The IP and MAC addresses of R are shown in Figure 2.

Host A (172.16.10.100) wants to ping host D (172.16.20.200). The following command is run on Host A:

ping –c 1 172.16.20.200

Question 2.1

Host A starts by sending out an ARP request. Complete Table 2.1 with the MAC addresses found in the Ethernet frame header encapsulating the ARP request and the ARP reply messages as captured at each Observation Point.

Question 2.2

Complete Table 2.2 with the addresses found inside the ARP messages captured by Observation Points 1 and 2.

Question 2.3

Host A can now send its Echo Request to host D. Complete Table 2.3 with the addresses included in the Ethernet and IP headers of the Echo Request and the Echo Reply captured at Observation Point 1.

Question 2.4

Suppose host A has sent pings to all other machines in this network. Complete Table 2.4 with the entries that can be found in A’s ARP table. Use keyword empty for cells with non-applicable value.

Question 2.5

Assume that host A is misconfigured with subnet mask 255.255.0.0. Which machines can host A ping?

Question 2.6

We now assume R is configured as an ARP proxy. As in previous question, we assume host A is configured with subnet mask 255.255.0.0.

Host A (172.16.10.100) wants to ping host D (172.16.20.200). The following command is run on Host A:

ping –c 1 172.16.20.200

A starts by sending an ARP request.

Complete Table 2.6 with the addresses found inside the ARP messages captured by Observation Points 1 and 2.

Host A can now send its Echo Request to host D. Complete Table 2.7 with the addresses included in the Ethernet and IP headers of the Echo Request and the Echo Reply captured at Observation Points 1 and 2.

Suppose host A has sent pings to all other machines in this network. Complete Table 2.8 with the entries that can be found in host A’s ARP table. Use keyword empty for cells with non-applicable value.

Final Words

Moodle offers a wide variety of questions that Moodle can grade (and regrade) automatically. Once created, questions are added to a question bank from where they can be reused or exported. These questions include Multiple choice, true-false, and matching questions but also Embedded-answers questions which offer a great level of flexibility.

Embedded-answers aka Cloze questions allow instructors to assess student understanding of more advanced topics. Once submitted, instructors can update the predefined answers. They can for instance add more partially correct answers to account for unanticipated student answers. Moodle can then regrade the student attempts accordingly. Feedback include the overall score and the question points but also a general and specific feedback shown to students depending on their answers.