Jump to:
Uniformity, Consistency and Readability
In this instructional guide we give some insight in the role a braille professional might play in the process of learning about computational thinking. The main role of the braille professional will be in the area of reading code or pseudo code. It is not necessary for a braille professional to master programming, but it may be useful to know something about the basic principles when helping a braille reader. We present these basic principles in combination with the problems that a braille reader might encounter. We also give some examples of exercises that can be done by the braille reader in collaboration with the braille professional.
Most of the guide focuses on the Python programming language. However, much of the information is also helpful for other programming languages. The information can also be used to write (pseudo) code in a text editor such as Word.
Structure of the Code
Python is an accessible programming language for braille readers and is relatively easy to learn. It is also widely used in school. We therefore advise that you use Python or start coding in Word. In order to use Python, the braille reader must be familiar with a few things.
First of all, Python has syntactic indentation. This means that the structure of the code is done by using tabs (or four spaces). An example of this is the following short code in which an if-statement starts and ends:
Example 1
1 g = 5
2 if g >= 5.5:
3 print("student passed")
4 else:
5 print("student failed")This example checks whether the input “g” (grade of the student) is enough for the student to pass (if the grade is 5,5 or greater), or that the student fails (in all other cases).
When a loop or if-statement starts, the information in the loop starts with an extra tab or four spaces. If a second loop or if-statement occurs within a first loop, this line starts with two tabs. This results in different levels of indentation, which are difficult to follow when working in braille. It is important to teach this to a braille reader so that they understand the structure of a code.
To learn about the structure of a code, the braille reader must be looking for clues before analysing the whole code. Exploring the structure of a code is a good first step. This can be done by checking the indentation levels of each line. This gives an overview of the number of loops in the code and gives insight in whether the loops are inside other loops.
Example 2
This code uses for-loops and executes the following: (1, 4), (1, 5), (2, 4), (2, 5)
1 x = [1, 2]
2 y = [4, 5]
3
4 for i in x:
5 for j in y:
6 print(i, j)Questions
- In which lines are the variables introduced?
- In which line does the first loop start and where does it end?
(Line 4 to 6) - In which line does the second loop start and where does it end?
(Line 5 to 6)
Note that there is a blank line in example 2. Blank lines can occur in codes when a new part of coding starts. This is mainly helpful for the overview of the code for visual programmers but can be confusing for braille readers. The braille reader should be aware of blank lines and understand that these are not the end of the code but divide the code into different parts. In this example, the blank line separates the introduction of the variables from the part where the variables are used.
Example 3
This code uses while-loops and executes the same as example 2: (1, 4), (1, 5), (2, 4), (2, 5)
1 x = [1, 2]
2 y = [4, 5]
3 i = 0
4 while i < len(x):
5 j = 0
6 while j < len(y):
7 print(x[i], y[j])
8 j = j + 1
9 i = i + 1Questions
- In which lines are the variables introduced?
(Line 1, 2 and 3) - In which line does the first loop start and where does it end?
(line 4 to 9) - In which line does the second loop start and where does it end?
(line 6 to 8)
All these exercises could be done either on paper or on a computer with a braille display. It is advisable to start with some codes on paper as this will give the braille reader an overview of the “shape” of the code. Make sure you use simple codes when using paper so that the lines fit the paper. When using 6-dot braille on paper, you must be aware that the braille notation of some symbols may differ from the braille notation on the computer (8-dot braille).
Constantly having to count the number of tabs in braille is exhausting and not necessary once the braille reader understand how it works. There are a couple of ways in which this can be overcome. These settings are possible solutions and should be installed in collaboration with the ICT professional. For more information about this part, we advise you to read the instructional guide on computational thinking for ICT professionals. For the braille professional, it is important to understand that certain settings in the computer can give the student auditive clues about the indentation. For example, every time a tab occurs in the code, the speech synthesis plays a certain sound or word.
Other languages such as Java or C have a structure based on brackets and so do not have the problem of a reliance on syntactic indentation. This can be easier for some braille readers, but it can also bring other problems, because working with a lot of brackets is exhausting as well.
Capitals
Python is a programming language that is case sensitive. This means that it differentiates between lower-case and upper-case letters. This is important for the braille reader, because the code might not work once a lower case is typed when an upper case is meant. When working with a braille reader, check whether the braille reader can properly discriminate between upper and lower-case letters.
It is possible to set a little sound whenever a capital occurs. Some braille readers find this helpful when programming. For more information about this, we advise to read the instructional guide on computational thinking for ICT professionals.
Uniformity, Consistency and Readability
When selecting code or learning to write code, braille readers must learn to write such that it is also easy to read back and to remember what they meant with their code. They have to make sure there is enough white space around the signs and text. This makes the text more fluent for the screen reader. Especially when using variables, it is important to put spaces on the right places. If this is done wrong, it is not possible to correctly determine the beginning or end of a variable.
| Variable | Explanation |
|---|---|
| childrenAndAdolescents | This is one variable, and you can hear that because there is no pauses between the words |
| children & Adolescents | These are two variables, and you can hear that because there are pauses between the words |
| children&Adolescents | These are two variables, but you cannot hear that because there are no pauses between the words |
A problem with these descriptive variables is that they are very long. Long variables are easier to remember but take a lot of space on the braille display. This makes it more difficult to read the rest of the code because the lines will not fit the braille display. This will always be a compromise that the braille reader or teacher must make. On the one hand variables should not be too long, but on the other hand they should be descriptive, correct and consistent. One could also compromise by leaving white spaces around the variables and operators. How one compromises depends on the preference of the braille reader.
By adding comments in between the lines, the code is shorter, but there is still enough information around to understand what the variables are about. Comments that have no function in the code, but only give some descriptive information always start with a hash symbol (#) and start at the beginning of that line until the end of that line.
Example
1 # This comment is only here for explanation
2 # This line also starts with a hash and ends here
3 print(“This is where the code starts”)
4 # print(“This will not be printed because there is a hash”)
In variables it is advised to start each new word with a capital. Example: numberOfChildren + numberOfAdolescents = totalNumberOfPeople
Navigating Through Code
When navigating through code, it can be annoying to continuously change between the braille display and the keyboard of the computer. Therefore, it is advised to use the braille display mainly for exploring details in the code and to use speech synthesis when navigating through the code. Details that should be explored with the braille display could be:
- Parentheses (the number of parentheses opening and closing)
- Capitals
- Start and end of loops
This is mainly important when exploring mistakes in the code. It could be that a code does not run properly because a parenthesis is missing or a letter that should be capitalized, is not capitalized. Therefore, the braille reader must be able to pay close attention to this.
Symbols
Programming languages contains more symbols than the braille reader encounters in the math lessons or other subjects in school. Also, it could be that the math operators in mathematics differ from the operators in the programming language. It is important to keep in mind that this can be confusing for a braille student. The exact braille notation that corresponds with all symbols is dependent on the national braille notation that is used in your country. It is important to look up the signs and them corresponding braille notation, and to teach these to the braille reader. This should not be taught all in once, but in close collaboration with the math teacher. It is most important that they know the name of a symbol. The meaning of the symbols should be explained by the math teacher. In the next couple of tables, the most important symbols and them meaning are shortly introduced.
Arithmetic Operators
| Operator | Name | Example |
|---|---|---|
| + | Addition | x + y |
| ‐ | Subtraction | x ‐ y |
| * | Multiplication | x * y |
| / | Division | x / y |
| % | Modulus | x % y |
| ** | Exponentiation | x ** y |
| // | Floor division | x // y |
Comparison Operators
| Operator | Name | Example |
|---|---|---|
| == | Equal | x == y |
| != | Not equal | x != y |
| > | Greater than | x > y |
| < | Less than | x < y |
| >= | Greater than or equal to | x >= y |
| <= | Less than or equal to | x <= y |
Brackets
| Operator | Name |
|---|---|
| ( ) | Parentheses |
| [ ] | Square brackets |
| { } | Curly brackets |
Other Symbols
Finally, other symbols that are frequently used in programming are the following:
, : . ` = ; ‘ ” # \ @
A lot more combinations between these symbols exist and all have a different meaning in programming. This is important to know, but the meaning of it must be taught to the braille reader by the math teacher and not by the braille professional.