1. Start Microsoft Visual Basic
2. To start a new project, on the main menu, click File -> New Project...
3. In the middle list, click Console Application
4. Change the Name to WattsALoan2
5. Click OK
6. On the main menu, click Project -> WattsALoan2 Properties
7. Click the arrow of the Application Type box and select Windows Forms Application
8. To create a new class, in the Solution Explorer, right-click WattsALoan2 -> Add -> Class...
9. In the middle list, make sure Class is selected.
   Change the Name to Customer and click Add
10. Change document as follows:
    

    Public Class Customer
        Public FullName As String
        Public PhoneNumber As String
    
        Public Sub New(Optional ByVal Name As String = "John Doe",
                       Optional ByVal Phone As String = "000-000-0000")
            FullName = Name
            PhoneNumber = Phone
        End Sub
    End Class

11. To create a new class, in the Class View, right-click WattsALoan2 -> Add -> Class...
12. Change the Name to Employee and press Enter
13. In the empty document, type the following:
    

    Public Class Employee
        Public EmployeeNumber As Long
        Public FirstName As String
        Public LastName As String
        Public Title As String
    
        Public Sub New(Optional ByVal EmplNbr As Long = 0,
                        Optional ByVal FName As String = "Unknown",
                        Optional ByVal LName As String = " Not Specified",
                        Optional ByVal Position As String = "Loan Specialist")
            EmployeeNumber = EmplNbr
            FirstName = FName
            LastName = LName
            Title = position
        End Sub
    
        Public Function GetEmployeeName() As String
            Return LastName + ", " + FirstName
        End Function
    End Class

14. To add a new class to the project, on the main menu, click Project -> Add Class...
15. Change the Name to LoanInformation
16. Click Add
17. In the empty document, type the following:

    Public Class LoanInformation
        Public Principal As Double
        Public InterestRate As Double
        Public Period As Double
        Public InterestAmount As Double
        Public FutureValue As Double
    End Class

18. In the Solution Explorer, right-click Module1.vb and click Rename
19. Type LoanEvaluation.vb and press Enter twice
20. In the empty document, type the following:

    Module LoanEvaluation
        Private Clerk As Employee
        Private Client As Customer
        Private Loan As LoanInformation
    
        Private Sub IdentifyEmployee()
            MsgBox("Enter the following pieces of information " +
                              "about the employee who prepared this loan.")
            Clerk.EmployeeNumber = CLng(InputBox("Employee #: ",
                                      "Watts A Loan?", "000000"))
            Clerk.FirstName = InputBox("First Name:")
            Clerk.LastName = InputBox("Last Name:")
            Clerk.Title = InputBox("Title:")
        End Sub
    
        Private Sub IdentifyCustomer()
            MsgBox("Enter the following pieces of information " +
                              "about the customer for whom this loan was prepared.")
            Client.FullName = InputBox("Customer Name:")
            Client.PhoneNumber = InputBox("Phone Number:")
        End Sub
    
        Private Sub GetLoanValues()
            MsgBox("Enter the following pieces of information " +
                              "about the values used for the loan.")
            Loan.Principal = CDbl(InputBox("Enter the principal:"))
            Loan.InterestRate = CDbl(InputBox("Enter the interest rate:")) / 100
            Loan.Period = CDbl(InputBox("Enter the number of months:")) / 12
        End Sub
    
        Public Sub Show()
            loan.InterestAmount = loan.Principal * loan.InterestRate * loan.Period
            loan.FutureValue = loan.Principal + loan.InterestAmount
    
            MsgBox("Watts A Loan?" & vbCrLf &
                   "========================" & vbCrLf &
                   "Loan Summary" & vbCrLf &
                   "-------------------------------------" & vbCrLf &
                   "Prepared by:" & vbTab & Clerk.EmployeeNumber & vbCrLf &
                   vbTab & vbTab & Clerk.GetEmployeeName() & vbCrLf &
                   vbTab & vbTab & Clerk.Title & vbCrLf &
                   "Prepared for:" & vbTab & Client.FullName & " - " &
                   Client.PhoneNumber & vbCrLf &
                   "-------------------------------------" & vbCrLf &
                   "Principal:" & vbTab & vbTab & Loan.Principal.ToString("F") & vbCrLf &
                   "Interest Rate:" & vbTab & Loan.InterestRate.ToString("P") & vbCrLf &
                   "Period:" & vbTab & vbTab & CStr(Loan.Period * 12) & " months" & vbCrLf &
                   "Interest Amount:" & vbTab & Loan.InterestAmount.ToString("F") & vbCrLf &
                   "Future Value:" & vbTab & Loan.FutureValue.ToString("F") & vbCrLf &
                   "========================",
                   MsgBoxStyle.OkOnly Or MsgBoxStyle.Information,
                   "Watts A Loan?")
        End Sub
        Public Function Main() As Integer
            Dim Clerk As Employee = New Employee
            Dim Client As Customer = New Customer
            Dim Loan As LoanInformation = New LoanInformation
    
            MsgBox("This application allows you to evaluate a loan",
                   MsgBoxStyle.OkOnly Or MsgBoxStyle.Information,
                   "Watts A Loan?")
            IdentifyEmployee()
            IdentifyCustomer()
    
            GetLoanValues()
    
            Show()
            Return 0
        End Function
    
    End Module

Instead of just one class or one file, we have learned that, to organize your project, you can create classes in different files. When you debug a project that uses different files that contain procedures and classes, the debugger is aware of the objects and where they are located. As we will learn later, there are various windows that assist you with identifying the objects of your project. As a result, the tools such as the Locals window display their contents accordingly.

As you know already, the starting point of a Visual Basic application is the Main() procedure. If you start debugging an application that uses many code files, the debugger must first identify the file that contains the Main() procedure. If you are debugging a normal console application and if the debugger cannot find a file that contains the Main() function, you would receive an error, indicating that your project does not contain an entry point.

1. To start debugging, on the main menu, click Debug -> Step Into.
   If you don't see the Locals window, on the main menu, click Debug -> Window -> Locals
    
   
2. Notice that the debugging yellow arrow indicator is positioned on the left of the Main() function.
   To continue debugging, on the main menu, click Debug -> Step Into
3. Again, on the main menu, click Debug -> Step Into
4. Read the message box and click OK
5. Press F8 three times until a message box comes up
6. Click OK on the message box.
   Notice that the debugging gets in the body of the IdentifyEmployee() function
7. To continue, press F8
   Notice that the debugger jumps to the Employee.vb file
8. In the Locals window, click the + button of Me to expand it. Notice that it shows the member variables of the class
    
   
9. To continue debugging, on the Standard toolbar, click the Step Into button continually to debug the Employee class and observe the values in the Locals window
10. Continue stepping into until the debugger switches back to the LoanEvaluation.vb file
11. Press F8 and notice that the IdentifyEmployee() function gets focus
12. Press F8 again twice
13. When requested, enter the Employee # as 80226 and click OK
14. Click the Step Into button
15. When asked for the first name, type David and click OK
16. Press F8
17. For the last name, type Boyton and click OK
18. Press F8
19. For the title, type Shift Supervisor and click OK.
    Observe the values in the Locals window
     
    
20. Press F8 a few times until the debugger gets to the Client = IdentifyCustomer() line
21. To continue, press F8 and observe the debugging
22. Click OK on the message box
23. Continue pressing F8 until the Customer.vb file gets focus
24. Continue pressing F8 until focus gets back to the LoanEvaluation.vb file
25. In the Locals window, click the + button of Me to expand it
     
    
26. Press F8 to continue debugging
27. When asked for the customer name, type Ann Nanze and click OK
28. Press F8
29. When asked for the phone number, type (106) 042-8636 and click OK
30. To continue debugging, press F8 a few times until a message box comes up
31. Read the message box and click OK
32. Press F8 to continue
33. In the Locals window, click the + button
     
    
34. Press F8 twice
35. When the principal is requested, type 1000 and click OK
36. Press F8
37. For the interest rate, type 16.05 and click OK
38. Press F8
39. For the period, enter 12 and click OK
     
    
40. Press F8
41. In the Locals window, click the second + button
     
    
42. On the Standard toolbar, click the Step Into button
43. In the Locals window, expand the nodes
     
    
44. Press F8
45. In the Locals window, expand the las + node to see the current values of the variables
     
    
46. Keep pressing F8 continually. Observe the evolution in the Code Editor and the values in the Locals window
47. When the message box comes up, review it and click OK
     
    
    
48. On the main menu, click File -> Close Solution or File -> Close Project
49. When asked whether you want to save, click Discard

You are probably familiar with the Error List window because if you have ever made any mistake in your code, it would come up. The Error List is a window that displays the list of the current errors in your code. Most of the times, the Error List is present, usually below the Code Editor. At any time, to display it, on the main menu, you can click View -> Error List or press Ctrl + W. While you are working on your code, the Error List may be minimized. To permanently keep it showing, you can click its AutoHide button.

The Error List uses two sequences of how it decides to show the errors. While writing your code, if the live parser, which continuously runs while you are writing your code, finds a problem, it makes a list of all types of violations, even if there is only one mistake, or there appears to be only one mistake. It shows the list in a table:

Another sequence or a different list may gets created if you build your code. This time, it would be the debugger's list. It is important to know that one mistake could be violating more than one rule of the Visual Basic language.

As seen in our introduction to syntax errors, if you are using Microsoft Visual Basic (whether Microsoft Visual Basic 2010 Express or Microsoft Visual Studio), while you are writing your code, if the parser senses a problem, it underlines the section in the Code Editor and the Error List shows its analysis of that problem. The Error list uses a table made of 5 columns that are Description, File, Line, Column, and Project. You don't have to use all those columns. To specify what columns to show or hide, right-click anywhere in the body of the Error List and position the mouse on Show Columns:

To show a column, put a check mark on its menu item. To hide a column, remove its check mark. The list of errors displays in an incremental order specified by the parser. Otherwise, you can arrange the order based on a column of your choice. To do this, right-click any entry in the Error List, position the mouse on Sort By, and click the column of your choice.

As mentioned already, the Error List uses various columns to show its findings:

•  The Description column shows a string that translates some meaning of the problem. The parser and the Error List make an effort to point the actual problem. Sometimes, the error pointed out is not easy to understand. Some other time, the error may not be completely true. Sometimes, if you fix one problem, all the other problems are solved. In our lessons, it is impossible to list all types of errors or all possible types of errors. With experience, you will know how to address and correct them
• The File column shows the name of the file. This is valuable if your project includes many files
• The Line column is probably a junior programmer's best friend. The Error List strives to display the line number in code where the problem happened, or probably happened. With experience, you will know that this is not always exact
• Like the Line number, the Column attempts to exactly point out the character area where the problem occurrent. Also with experience, you will find out that the Error List sometimes shows where it sensed the problem, not necessairy when it happened
• The Project column gives the name of the project in which the error occurred. This can be valuable if you are working on many projects, or rather on a solution that includes many projects

To jump to an error from the Error List, locate the error and double-click it. The caret would be positioned to that Line number, that character Column or word, and in that File of that Project. If you correct the problem and if the parser concludes that your correction is fine, the error would be automatically removed from the Error List. You can continue this to correct all problems and, eventually, the Error List would be emptied.