# Coding for Kids #2. Code!

In my last post, I introduced the problem we’re trying to solve via an introductory computer program:  finding 100 point words where each letter of the alphabet corresponds to its place in the alphabet (A=1, B=2 … Z=26).  At this point, we’ve built the basic template for the app, but haven’t yet written any code.   It’s time to write some basic functions (or methods) that help solve this.

For coding veterans, remember – this initially is about solving the problem as a beginner and optimizing later.

When programming, it’s often easiest to work backwards – that is, the program flow is getting the user input, parsing it, then determining the value.   To write code to do this, it’s easiest to determine the value of a character first, working backwards.   So, let’s write a simple method that does this.   We’ll want a method that accepts a character, and returns an integer.  Within the code template established in the first post, add a method like this under the button click event handler:

``````    1:  private void btnCalculate_Click(object sender, EventArgs e)
``````
``````    2:  {
``````
``````    3:
``````
``````    4:  }
``````
``````    5:
``````
``````    6:  /// <summary>
``````
``````    7:  /// Returns the value of a given character, where the
``````
``````    8:  /// value is determined by its location in the alphabet.
``````
``````    9:  /// </summary>
``````
``````   10:  /// <param name="c">The character to be evaluated.</param>
``````
``````   11:  /// <returns>The numerical value of the character.</returns>
``````
``````   12:  private int getCharacterValue(char c)
``````
``````   13:  {
``````
``````   14:      if (c == 'a') return 1;
``````
``````   15:      if (c == 'b') return 2;
``````
``````   16:      if (c == 'c') return 3;
``````
``````   17:      // ...
``````
``````   18:      if (c == 'z') return 26;
``````
``````   19:
``````
``````   20:      return 0;
``````
``````   21:  }
``````

The green text are comments.  Like the button method above it (that doesn’t do anything), our method is private (means it can only be used in this class), returns an integer (int), is called getCharacterValue, and accepts a character (char) we’ll just call c.  Normally, you’d want your variables, like c, to be clear names … such as firstName or dateOfBirth.  But for a simple character, it’s common to just use a single letter like this.  Remember, c is not “C” as in the letter of the alphabet – c is a variable that represents any possibly character.   All the code within the method must be encapsulated with curly braces { }.

Notice that we have a bunch of if statements.  An if statement evaluates a condition in parentheses.  If the condition is true, it executes the code that follows.    We could optionally execute multiple lines of code by putting it in curly braces, or include an else section.   The return command stops executing code, and returns the value if the function is true.

So, suppose that we do something like:

`````` int charValue = getCharacterValue('b');
``````

The runtime (that is, what is executing our code) calls our getCharacterValue function passing in ‘b’.  We’re assigning the result of that call to an integer called charValue.   Logically, you know the result should be 2, and therefore, charValue should be 2.  If you were to follow the function as it executes, it would hit line 14 and see if the character is an ‘a’ … it’s not, so it keeps going.  It is a ‘b’, so it immediately stops executing and returns 2.

If the character passed in is ‘z’, you can see that it’s relatively inefficient.  We’re evaluating 26 if statements.   We’ll address that another time, but for now, it’ll do.   If it gets all the way to the end, we’ll return 0.

My daughter asked me why we use 2 equal signs when comparing … such as c == ‘a’ … the short version is that one equal sign is assignment, whereas two is an evaluation.   Notice that in my one line sample code, we’re assigning charValue with a single equal sign.  That means we’re assigning the value of that function to our variable charValue.   Remember that computers need precise instructions, and so, in the if statements, we’re asking the runtime if these two things are the same – we’re asking it to evaluate.

We now have a method that determines the value of a single character … but what about an entire word?  Multiple characters in a computer program are called a string.   What we need to do is write another function that accepts a string, parses it for each character in the string, adding up the value of each character along the way.

To solve this, we need a variable to keep track of each character’s value.   We also need a way to look at each character in a string.  Fortunately, there’s an easy way to do that.

``````    1:  private int getWordValue(string theWord)
``````
``````    2:  {
``````
``````    3:      int wordValue = 0;
``````
``````    4:
``````
``````    5:      foreach (char c in theWord)
``````
``````    6:      {
``````
``````    7:          wordValue += getCharacterValue(c);
``````
``````    8:      }
``````
``````    9:
``````
``````   10:      return wordValue;
``````
``````   11:  }
``````

When our function is called, we’ll use a temporary variable called wordValue that we initially assign to zero.  Next we have a foreach statement.  A foreach is a fancy kind of loop.   There are different kinds of loops, with subtle advantages and disadvantages.  A foreach makes it easy to iterate over objects in a collection – in this case, characters in a string.

What the foreach is saying is that for every character (called c) in theWord, execute the code in curly braces.  In that code block, we assign wordValue to itself plus the value of getCharacterValue of the current character in theWord.  (The += means ‘itself plus…’.)   If the word is “test”, the foreach code block is executed 4 times, the first time c is ‘t’, then ‘e’, then ‘s’, then ‘t’.  When that is done, wordValue should be the sum of each character’s value, so we’ll just return that.

Now all we need to do is make it so when the button is clicked, we grab the value of the YourWord textbox, and display it in the WordValue textbox.

`````` private void btnCalculate_Click(object sender, EventArgs e)
{
txtWordValue.Text = getWordValue(txtYourWord.Text).ToString();
}
``````

We can do this in one line of code in our button event handler.  First, one thing to know is that classes encapsulate functionality.  A TextBox is a class, as is our button.  We don’t have to worry about the inner workings of the textbox – such as how to draw the box, handle user input, etc.   The textbox contains a number of properties that can be accessed that make it easy for us to get or set the value of something within the class.  In the case of the textbox, it has a Text property that lets us get or set the value of the text in the textbox.  Properties are accessed by using a “.” – so, in the line above, we’re assigning the value of the Text property in the txtWordValue, and also reading the value of the Text property in the txtYourWord textbox.

We call getWordValue, passing in the txtYourWord.Text value, which would be whatever the user types in the box.  Now, what’s that ToString()?   You’ll see ToString() a lot in C#.  Remember, with C# and many languages, you need to be very precise.  When getWordValue returns, what is it?  It’s an integer.  A whole number.  Computers deal with numbers differently and more simply than they do strings.   The Text property of the textbox gives you a string, and also expects a string if being assigned to.  We have a number.  So, in essence, calling ToString() turns, for example, the number 42 into the string “42”.

Let’s hit F5 and run the program.  Using the word “test”, we’ll see the following.  We’ll also try “automated” – an apropos 100 point word!  Let’s not get too excited.  Let’s try it again, this time using the word “Automated” (notice the capital “A”): Our first bug.  We’ve barely written code and it’s already inefficient, buggy, etc.  The problem is that “A” is not the same as “a” … there are a number of ways to solve this, but we’ll look at those in part 3. In the meantime, here’s the code for this version:  