Merged master into current and resolved conflict

Author: moisedk

pretext/GeneralIntro/FormalandNaturalLanguages.ptx

@@ -55,11 +55,11 @@
       <p>Formal languages mean exactly what they say.  On the other hand,
                             natural languages are full of idiom and metaphor. If someone says, <q>The
                             other shoe fell</q>, there is probably no shoe and nothing falling.</p>
-      <tip>
+      <note>
         <p>You'll need to find the original joke to understand the idiomatic
                                 meaning of the other shoe falling.  <em>Yahoo! Answers</em> thinks it
                                 knows!</p>
-      </tip>
+      </note>
     </gi>
   </glossary>
   <p>People who grow up speaking a natural language&#x2014;everyone&#x2014;often have a hard

pretext/Inheritance/04-ReuseThroughComposition.ptx

@@ -38,7 +38,7 @@ print(p.distanceFromOrigin())
         </input>
   </program>
   <p>The first thing to notice about this version of LabeledPoint
-            does not inherit from Point. Instead, its constructor
+            is that it does not inherit from Point. Instead, its constructor
             instantiates a Point and stores a reference to it in its <c>point</c>
             instance variable so that it can be used by the other methods.</p>
   <p>Next, notice how the <c>distanceFromOrigin()</c> method reuses the code in

pretext/IntroRecursion/TheThreeLawsofRecursion.ptx

@@ -29,7 +29,7 @@
             algorithm our primary data structure is a list, so we must focus our
             state-changing efforts on the list. Since the base case is a list of
             length 1, a natural progression toward the base case is to shorten the
-            list. This is exactly what happens on line 5 of <xref ref="intro-recursion_calculatingthe-sumofa-listof-numbers"/> when we call <c>listsum</c> with a shorter list.</p>
+            list. This is exactly what happens on line 5 of the ActiveCode in <xref ref="intro-recursion_calculating-the-sum-of-a-list-of-numbers"/> when we call <c>listsum</c> with a shorter list.</p>
   <p>The final law is that the algorithm must call itself. This is the very
             definition of recursion. Recursion is a confusing concept to many
             beginning programmers. As a novice programmer, you have learned that

pretext/IntroRecursion/intro-VisualizingRecursion.ptx

@@ -29,8 +29,8 @@
             going off to the left. If you think of this definition recursively it
             means that we will apply the recursive definition of a tree to both of
             the smaller left and right trees.</p>
-  <p>Let's translate this idea to some Python code. <xref ref="lst-fractree"/>
-            shows how we can use our turtle to generate a fractal tree. Let's look at
+  <p>Let's translate this idea to some Python code. The <xref ref="intro-recursion_lst-fractree"/>
+            below shows how we can use our turtle to generate a fractal tree. Let's look at
             the code a bit more closely. You will see that on lines 5 and 7 we are
             making a recursive call. On line 5 we make the recursive call right
             after the turtle turns to the right by 20 degrees; this is the right

pretext/Selection/Logicaloperators.ptx

@@ -222,7 +222,7 @@ print(n % 2 == 0 or n % 3 == 0)
     </tabular>
   </table>
   <p>Also, Google has provided this short video showing different logical operators:</p>
-  <video xml:id="GoogleLogic" youtube="57dPVbnRouU" width="667"/>
+  <video xml:id="GoogleLogic" youtube="57dPVbnRouU" width="auto"/>
   <p>In the video, each letter is representative of a logical operater and only shows its color when the
             corresponding <term>x</term> or <term>y</term> is showing in the second <term>G</term>. If you take a look at xor, you will notice
             it is only colorful when either <term>x</term> or <term>y</term> is showing, but not both. This is called <c>exclusive or</c>,

pretext/SimplePythonData/Input.ptx

@@ -95,6 +95,36 @@ print ( type(n) )
       </choice>
     </choices>
   </exercise>
-  <exercise runestone="ca_id_ints"/>
-  <exercise runestone="ca_id_str"/>
+  <exercise label="test_question2_7_2">
+
+    <statement>
+      <p>Click on all of the variables of type `int` in the code below</p>
+    </statement>
+    <areas>
+    <cline><area correct="no">seconds</area> = input("Please enter the number of seconds you wish to convert")</cline>
+    <p></p>
+    <cline><area>hours</area> = int(<area correct="no">seconds</area>) // 3600</cline>
+    <cline><area>total_secs</area> = int(<area correct="no">seconds</area>)</cline>
+    <cline><area>secs_still_remaining</area> = <area>total_secs</area> % 3600</cline>
+    <cline>print(<area>secs_still_remaining</area>)</cline>
+
+
+    </areas>
+  </exercise>
+  <exercise label="test_question2_7_3">
+
+    <statement>
+      <p>Click on all of the variables of type `str` in the code below</p>
+    </statement>
+    <areas>
+    <cline><area>seconds</area> = input("Please enter the number of seconds you wish to convert")</cline>
+    <p></p>
+    <cline><area correct ="no">hours</area> = int(<area>seconds</area>) // 3600</cline>
+    <cline><area correxct="no">total_secs</area> = int(<area>seconds</area>)</cline>
+    <cline><area correct="no">secs_still_remaining</area> = <area correct="no">total_secs</area> % 3600</cline>
+    <cline>print(<area correct ="no">secs_still_remaining</area>)</cline>
+
+
+    </areas>
+  </exercise>
 </section>

pretext/SimplePythonData/VariableNamesandKeywords.ptx

@@ -5,9 +5,9 @@
             digits, but they have to begin with a letter or an underscore. Although it is
             legal to use uppercase letters, by convention we don't. If you do, remember
             that case matters. <c>Bruce</c> and <c>bruce</c> are different variables.</p>
-  <caution>
+  <warning>
     <p>Variable names can never contain spaces.</p>
-  </caution>
+  </warning>
   <p>The underscore character ( <c>_</c>) can also appear in a name. It is often used in
             names with multiple words, such as <c>my_name</c> or <c>price_of_tea_in_china</c>.
             There are some situations in which names beginning with an underscore have
@@ -153,7 +153,7 @@ class = "Computer Science 101"</pre>
   <p>Programmers generally choose names for their variables that are meaningful to
             the human readers of the program &#x2014; they help the programmer document, or
             remember, what the variable is used for.</p>
-  <caution>
+  <warning>
     <p>Beginners sometimes confuse <q>meaningful to the human readers</q> with
                 <q>meaningful to the computer</q>.  So they'll wrongly think that because
                 they've called some variable <c>average</c> or <c>pi</c>, it will somehow
@@ -166,7 +166,7 @@ class = "Computer Science 101"</pre>
                 the programmer, have to write some program code to calculate the average,
                 or you must write an assignment statement to give a variable the value you
                 want it to have.</p>
-  </caution>
+  </warning>
   <p>
     <term>Check your understanding</term>
   </p>

pretext/SimplePythonData/Variables.ptx

@@ -25,10 +25,10 @@ pi = 3.14159
 17 = n
 </input>
   </program>
-  <tip>
+  <note>
     <p>When reading or writing code, say to yourself <q>n is assigned 17</q> or <q>n gets
                 the value 17</q> or <q>n is a reference to the object 17</q> or <q>n refers to the object 17</q>.  Don't say <q>n equals 17</q>.</p>
-  </tip>
+  </note>
   <p>A common way to represent variables on paper is to write the name with an arrow
             pointing to the variable's value. This kind of figure, known as a <term>reference diagram</term>, is often called a <term>state
                 snapshot</term> because it shows what state each of the variables is in at a

pretext/UnitTesting/Exercises.ptx

@@ -67,9 +67,6 @@ myTests().main()
             <p>If you're not sure how to get started with this one, review <xref ref="unit-testing_writing-unit-tests"/>.</p>
           </hint>
           <solution>
-                        assert reverse('abc') == 'cba'
-assert reverse('b') == 'b'
-assert reverse('') == ''
 
                         <pre>assert reverse('abc') == 'cba'
 assert reverse('b') == 'b'
@@ -115,13 +112,6 @@ myTests().main()
             <p>Review <xref ref="unit-testing_designing-testable-functions"/>.</p>
           </hint>
           <solution>
-                        def stripletters(msg):
-    result = ''
-    for ch in msg:
-        if not ch.isalpha():
-            result += ch
-
-    return result
 
                         <pre>def stripletters(msg):
     result = ''

pretext/WebApps/07-InputForAFlaskWebApplication.ptx

@@ -20,7 +20,7 @@
             <em>python+flask</em>, and a variable named <c>go</c> whose value is <em>Submit</em>.</p>
   <p>Flask applications can access query variables using a dictionary named
             <c>request.args</c> (dictionaries are discussed in detail in
-            <xref ref="dictionaries_intro--dictionaries"/>).
+            <xref ref="dictionaries_dictionaries"/>).
             When a browser sends a request to a Flask application that contains
             a query string, the data in the query string is placed in the <c>request.args</c>
             dictionary, where it can be retrieved by the application. For example, in the Bing search