several updates following discussions

- Replaced `char` with `nucleotide` as this is terminology from the domain.
- Rephrased a "see also" link to be more screen reader friendly.
- A note about the exercise not requiring tests for invalid characters is preset in one
  of the approaches. Copied it over to the other approach, for uniformity.
- Rephrased mention about performance and speedup.
- Replaced mention of ASCII with Unicode adding a brief explanation and links.

Author: petrem

exercises/practice/rna-transcription/.approaches/dictionary-join/content.md

@@ -5,7 +5,7 @@ LOOKUP = {"G": "C", "C": "G", "T": "A", "A": "U"}
 
 
 def to_rna(dna_strand):
-    return ''.join(LOOKUP[char] for char in dna_strand)
+    return ''.join(LOOKUP[nucleotide] for nucleotide in dna_strand)
 
 ```
 
@@ -33,11 +33,16 @@ LOOKUP = {"G": "C", "C": "G", "T": "A", "A": "U"}
 
 
 def to_rna(dna_strand):
-    return ''.join([LOOKUP[char] for char in dna_strand])
+    return ''.join([LOOKUP[nucleotide] for nucleotide in dna_strand])
 ```
 
 For a relatively small number of elements, using lists is fine and may be faster, but as the number of elements increases, the memory consumption increases and performance decreases.
-See also [this discussion][list-comprehension-choose-generator-expression] regarding when to choose one over the other.
+You can read more about [when to choose generators over list comprehensions][list-comprehension-choose-generator-expression] to dig deeper into the topic.
+
+
+~~~~exercism/note
+As of this writing, no invalid DNA characters are in the argument to `to_rna()`, so there is no error handling required for invalid input.
+~~~~
 
 [dictionaries]: https://docs.python.org/3/tutorial/datastructures.html?#dictionaries
 [const]: https://realpython.com/python-constants/

exercises/practice/rna-transcription/.approaches/dictionary-join/snippet.txt

@@ -2,4 +2,4 @@ LOOKUP = {"G": "C", "C": "G", "T": "A", "A": "U"}
 
 
 def to_rna(dna_strand):
-    return ''.join(LOOKUP[char] for char in dna_strand)
+    return ''.join(LOOKUP[nucleotide] for nucleotide in dna_strand)

exercises/practice/rna-transcription/.approaches/introduction.md

@@ -7,7 +7,7 @@ Another approach is to do a dictionary lookup on each character and join the res
 ## General guidance
 
 Whichever approach is used needs to return the RNA complement for each DNA value.
-The `translate()` method with `maketrans()` transcribes using the [ASCII][ASCII] values of the characters.
+The `translate()` method with `maketrans()` transcribes using the [Unicode][Unicode] code points of the characters.
 Using a dictionary look-up with `join()` transcribes using the string values of the characters.
 
 ## Approach: `translate()` with `maketrans()`
@@ -30,16 +30,17 @@ LOOKUP = {"G": "C", "C": "G", "T": "A", "A": "U"}
 
 
 def to_rna(dna_strand):
-    return ''.join(LOOKUP[char] for char in dna_strand)
+    return ''.join(LOOKUP[nucleotide] for nucleotide in dna_strand)
 
 ```
 
 For more information, check the [dictionary look-up with `join()` approach][approach-dictionary-join].
 
 ## Which approach to use?
 
-The `translate()` with `maketrans()` approach benchmarked many times faster than the dictionary look-up with `join()` approach.
+If performance matters, consider using the [`translate()` with `maketrans()` approach][approach-translate-maketrans].
+How an implementation behaves in terms of performance may depend on the actual data being processed, on hardware, and other factors.
 
-[ASCII]: https://www.asciitable.com/
+[Unicode]: https://en.wikipedia.org/wiki/Unicode
 [approach-translate-maketrans]: https://exercism.org/tracks/python/exercises/rna-transcription/approaches/translate-maketrans
 [approach-dictionary-join]: https://exercism.org/tracks/python/exercises/rna-transcription/approaches/dictionary-join

exercises/practice/rna-transcription/.approaches/translate-maketrans/content.md

@@ -15,8 +15,12 @@ Python doesn't _enforce_ having real constant values,
 but the `LOOKUP` translation table is defined with all uppercase letters, which is the naming convention for a Python [constant][const].
 It indicates that the value is not intended to be changed.
 
-The translation table that is created uses the [ASCII][ASCII] values (also called the ordinal values) for each letter in the two strings.
-The ASCII value for "G" in the first string is the key for the ASCII value of "C" in the second string, and so on.
+The translation table that is created uses the [Unicode][Unicode] _code points_ (sometimes called the ordinal values) for each letter in the two strings.
+As Unicode was designed to be backwards compatible with [ASCII][ASCII] and because the exercise uses Latin letters, the code points in the translation table can be interpreted as ASCII.
+However, the functions can deal with any Unicode character.
+You can learn more by reading about [strings and their representation in the Exercism Python syllabus][concept-string].
+
+The Unicode value for "G" in the first string is the key for the Unicode value of "C" in the second string, and so on.
 
 In the `to_rna()` function, the [`translate()`][translate] method is called on the input,
 and is passed the translation table.
@@ -32,3 +36,5 @@ As of this writing, no invalid DNA characters are in the argument to `to_rna()`,
 [const]: https://realpython.com/python-constants/
 [translate]: https://docs.python.org/3/library/stdtypes.html?#str.translate
 [ASCII]: https://www.asciitable.com/
+[Unicode]: https://en.wikipedia.org/wiki/Unicode
+[concept-strings]: https://exercism.org/tracks/python/concepts/strings