Install Microsoft Small Basic from here (it’s completely free). Click Download Small Basic, and just follow the instructions. When the installation is complete, you will have a start menu item that looks like this:

Now, things are really easy. A document is a program. Write your code and hit F5 to run it. Here I have written a Hello world program, started it, and the result is this:

Press any key to continue editing.

Context help is always displayed to the right in the main windows of Small Basic, so that you will always know what the code you write actually does. And if you don’t know what to write at all, an easy tutorial can be found here.

Are you looking for a random number generator, try Math.GetRandomNumber. Specify the largest number you want. This code will display 100 numbers between 1 and 10.

For I=1 To 100
  TextWindow.WriteLine(Math.GetRandomNumber(10))
EndFor

Dim MyString As String

…and…

Dim MyString As String = Nothing

If you create an extension method on the String class, and you write it in such fashion that it can handle uninitialized variables, it will be able to do so. The extension is done to the type, not to the object. This is an example of a function that checks if a string is empty:

<System.Runtime.CompilerServices.Extension()> _
Public Function IsEmpty(ByVal S As String) As Boolean
   If S Is Nothing Then
      Return True
   Else
      Return (S = "")
   End If
End Function

When the above extension is present, the following piece of code…

Dim MyString As String = Nothing
Console.WriteLine(MyString.IsEmpty())

…displays the word True in your console window!

#Create a connection object and open it.
[String]$cns="Data Source=XXX;Initial Catalog=Northwind;
   Integrated Security=True"
[System.Data.SqlClient.SqlConnection]$connection=New-Object
   -TypeName System.Data.SqlClient.SqlConnection -ArgumentList $cns
$connection.Open()

#Create a command and execute it.
[String]$query="SELECT FirstName, LastName
   FROM dbo.Employees ORDER BY LastName, FirstName"
[System.Data.SqlClient.SqlCommand]$command=New-Object
   -TypeName System.Data.SqlClient.SqlCommand
$command.Connection=$connection
$command.CommandText=$query
$r=$command.ExecuteReader()

#Iterate the result.
while($r.Read()) {

    #Read out first name.
    [String]$firstname=""
    if( -not $r.IsDBNull(0)) {
        $firstname=$r.GetString(0)
    }

    #Read out last name.
    [String]$lastname=""
    if( -not $r.IsDBNull(1)) {
        $lastname=$r.GetString(1)
    }

    #Display.
    Write-Output ($firstname + " " + $lastname)
}

#Close the reader.
$r.Close()

$connection.Close()
$connection.Dispose()

Here I use column indexes when referring to columns. A change in the SQL query will produce errors in the code that reads out the result. The solution is to call the GetOrdinal function of the reader to get the indexes of the columns, like this:

#Create a connection object and open it.
[String]$cns="Data Source=XXX;Initial Catalog=Northwind;
   Integrated Security=True"
[System.Data.SqlClient.SqlConnection]$connection=New-Object
   -TypeName System.Data.SqlClient.SqlConnection -ArgumentList $cns
$connection.Open()

#Create a command and execute it.
[String]$query="SELECT FirstName, LastName
   FROM dbo.Employees ORDER BY LastName, FirstName"
[System.Data.SqlClient.SqlCommand]$command=New-Object
   -TypeName System.Data.SqlClient.SqlCommand
$command.Connection=$connection
$command.CommandText=$query
$r=$command.ExecuteReader()

#Get use named columns.
[int]$Index_FirstName=$r.GetOrdinal("FirstName")
[int]$Index_LastName=$r.GetOrdinal("LastName")

#Iterate the result.
while($r.Read()) {

    #Read out first name.
    [String]$firstname=""
    if( -not $r.IsDBNull($Index_FirstName)) {
        $firstname=$r.GetString($Index_FirstName)
    }

    #Read out last name.
    [String]$lastname=""
    if( -not $r.IsDBNull($Index_LastName)) {
        $lastname=$r.GetString($Index_LastName)
    }

    #Display.
    Write-Output ($firstname + " " + $lastname)
}

#Close the reader.
$r.Close()

$connection.Close()
$connection.Dispose()

Now, if you change the the query, the reader will still find the desired columns.

4. Software. The “killer software” that makes a Mac worth owning (Safari, Cubase, Photoshop, Propellerheads Reason, Firefox) is perfectly available on Windows. Also, for each Mac specific application you can find, there are at least ten Windows specific alternatives.

3. Memory cost. A larger number of vendors and in some cases larger vendors, provides customer value.

2. Ease of use. Windows is well documented, logically constructed. To install an application on Windows, you download it and confirm that you want to install it. You don’t have to know what drag and drop operations that you expect to perform, and therefore, you don’t need any experience to get by. Experience gives you advantages, but is not required.

1. Customisation and extensibility. The smallest edition of the extremely powerful code editor is free to use for any purpose, and just about any Microsoft application comes with a well documented programming interface. And if you want to start from scratch, the .NET Framework is without competition. In both cases, no matter what programming language you know.

An iterator is similar to a function that returns a collection, but an iterator allows the caller to iterate before the collection is populated. The iterator is implemented as a function with the keyword Iterator, but it is actually compiled to an object.

Public Iterator Function Test() As IEnumerable(Of Integer)

This is an iterator named Test that returns integers. The return type declared must be an IEnumerable of the type your iterator contains. This iterator returns Integer values, and therefore the return type is set to an IEnumerable(Of Integer). This is a usage example of our iterator:

For Each I As Integer In Me.Test()
   MessageBox.Show(I.ToString())
Next

Of course, a bunch of integer values will pop up on screen. But lets check the full implementation of the Test iterator.

Public Iterator Function Test() As IEnumerable(Of Integer)
   Yield 10
   Yield 20
   Yield 30
End Function

When the For Each loop is done iterating, three message boxes have popped up. They first displays 10, the second 20 and the third 30. So why not just return an array of {10, 20, 30}?

Like I mentioned, a function that returns a collection must load the collection before returning it. Imagine that you want to return 10 objects, each object takes one second to load. This gives you a pause of 10 seconds before the iteration starts. Example:

Public Function ReturnTenThings() As List(Of String)
   Dim Ret As New List(Of String)()
   For I As Integer = 0 To 9
      Threading.Thread.Sleep(1000)
      Ret.Add((I + 1).ToString())
   Next
   Return Ret
End Function

This iteration will not start until 10 seconds have passed:

For Each X As String In Me.ReturnTenThings()
   MessageBox.Show(X)
Next

If we rewrite ReturnTenThings to be an iterator, like this…

Public Iterator Function ReturnTenThings() As IEnumerable(Of String)
   Dim Ret As New List(Of String)()
   For I As Integer = 0 To 9
      Threading.Thread.Sleep(1000)
      Yield (I + 1).ToString()
   Next
End Function

…the same iteration will still take 10 seconds to complete, but it will start after just one second.

Finally, a word of warning. If you need to know before you start your iteration, how many elements it holds, don’t just read the Count property of your iterator, because that will execute your code. If you need to know, copy the elements to a list, and read the Count property of that list. This code will take 20 seconds to execute, because the iterator runs twice:

MessageBox.Show(Me.ReturnTenThings().Count.ToString())
For Each X As String In Me.ReturnTenThings()
   MessageBox.Show(X)
Next

Protected Overrides Function ProcessCmdKey(ByRef msg
   As System.Windows.Forms.Message, ByVal keyData
   As System.Windows.Forms.Keys) As Boolean

This method gets called no matter what key is pressed. Also, if you act on the key, and don’t want the original functionality, make the function return True. If you want the framework to act on the key press, make the function return False.

If Strings(A1) = Strings(A2) Then

When the String.Compare function is used, the ten million tests are done in somewhere between 3.35 to 3.39 seconds. For me, case sensitive tests tend to be slightly slower.

If String.Compare(Strings(A1), Strings(A2)) = 0 Then

The reason that the equals operator is faster, is because it only compares the addresses where the strings are located, and since strings are unique in .NET, two strings with the same value, are stored in the same address. The Compare function looks at the characters in the string, and is therefore slower.

This is the disassembly for the test with the equals operator:

0000018f  mov         eax,dword ptr [ebp-50h]
00000192  mov         edx,dword ptr [ebp-48h]
00000195  cmp         eax,dword ptr [edx+4]
00000198  jb          0000019F
0000019a  call        67E075C0
0000019f  mov         eax,dword ptr [edx+eax*4+0Ch]
000001a3  mov         dword ptr [ebp+FFFFFF70h],eax
000001a9  mov         eax,dword ptr [ebp-54h]
000001ac  mov         edx,dword ptr [ebp-48h]
000001af  cmp         eax,dword ptr [edx+4]
000001b2  jb          000001B9
000001b4  call        67E075C0
000001b9  mov         eax,dword ptr [edx+eax*4+0Ch]
000001bd  mov         dword ptr [ebp+FFFFFF6Ch],eax
000001c3  push        0
000001c5  mov         ecx,dword ptr [ebp+FFFFFF70h]
000001cb  mov         edx,dword ptr [ebp+FFFFFF6Ch]
000001d1  call        558156C0
000001d6  mov         dword ptr [ebp-74h],eax
000001d9  cmp         dword ptr [ebp-74h],0
000001dd  sete        al
000001e0  movzx       eax,al
000001e3  mov         dword ptr [ebp-64h],eax
000001e6  cmp         dword ptr [ebp-64h],0
000001ea  je          00000201

This is the disassembly for the test with the String.Compare function:

0000018f  mov         eax,dword ptr [ebp-50h]
00000192  mov         edx,dword ptr [ebp-48h]
00000195  cmp         eax,dword ptr [edx+4]
00000198  jb          0000019F
0000019a  call        67F275C0
0000019f  mov         ecx,dword ptr [edx+eax*4+0Ch]
000001a3  mov         eax,dword ptr [ebp-54h]
000001a6  mov         edx,dword ptr [ebp-48h]
000001a9  cmp         eax,dword ptr [edx+4]
000001ac  jb          000001B3
000001ae  call        67F275C0
000001b3  mov         edx,dword ptr [edx+eax*4+0Ch]
000001b7  call        5E514300
000001bc  mov         dword ptr [ebp-74h],eax
000001bf  cmp         dword ptr [ebp-74h],0
000001c3  sete        al
000001c6  movzx       eax,al
000001c9  mov         dword ptr [ebp-64h],eax
000001cc  cmp         dword ptr [ebp-64h],0
000001d0  je          000001E7

It looks less, but it does more. The actual comparing is not shown, but it checks character until a mismatch is found. Since the difference is big, it’s important to pick the right method. If you add the compile option to compare text as text, the equal operator is almost just as slow as the String.Compare function, so the impact for this option…

Option Compare Text

…is huge.

#Load the Windows Forms library.
[string]$WindowsFormsLibrary =
"System.Windows.Forms,Version=2.0.0.0,Culture=neutral,PublicKeyToken=b77a5c561934e089"
[System.Reflection.Assembly]::Load($WindowsFormsLibrary)

#Load the Drawing library.
[string]$DrawingLibrary =
"System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
[System.Reflection.Assembly]::Load($DrawingLibrary)

#Create a window, and set its properties.
[System.Windows.Forms.Form]$f = New-Object System.Windows.Forms.Form
$f.Width = 500
$f.Height = 300

#Display the form.
$f.Show()
#Force a complete draw before we add any graphics.
$f.Refresh()

#Acquire the graphics interface.
[System.Drawing.Graphics]$g = $f.CreateGraphics()

#Draw anything you like here using GDI+.
$g.DrawLine([System.Drawing.Pens]::Black, 50, 20, 450, 250)
$g.DrawLine([System.Drawing.Pens]::Black, 450, 20, 50, 250)

#Dispose the graphics interface.
$g.Dispose()

#Wait for 5 seconds before closing it all down.
Start-Sleep -s 5
$f.Close()
$f.Dispose()

If we take the trouble to create a custom type based on the Form class, we can create form has double buffering enabled by definition, and is of correct size by definition. The size can be set from outside the form as shown above, but the DoubleBuffered property that controls double buffering could not. So by just replacing the predefined Form class with a custom extension, we are slightly closer to our goal.

#Load the Windows Forms library.
[string]$WindowsFormsLibrary =
"System.Windows.Forms,Version=2.0.0.0,Culture=neutral,PublicKeyToken=b77a5c561934e089"
[System.Reflection.Assembly]::Load($WindowsFormsLibrary)

#Load the Drawing library.
[string]$DrawingLibrary =
"System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
[System.Reflection.Assembly]::Load($DrawingLibrary)

#Create a custom form with double buffering.
$Refs = @("System.Windows.Forms", "System.Drawing")
Add-Type -ReferencedAssemblies $Refs @'
public class MyGraphicsForm:System.Windows.Forms.Form
{
   private System.ComponentModel.IContainer components = null;

   protected override void Dispose(bool disposing)
   {
      if (disposing && (components != null))
      {
         components.Dispose();
      }
      base.Dispose(disposing);
   }

   private void InitializeComponent()
   {
      this.SuspendLayout();
      this.ClientSize = new System.Drawing.Size(500, 300);
      this.DoubleBuffered = true;
      this.Text = "My graphics form";
      this.ResumeLayout(false);

   }
}
'@

#Create our custom window.
[System.Windows.Forms.Form]$f = New-Object MyGraphicsForm

#Display the form.
$f.Show()
#Force a complete draw before we add any graphics.
$f.Refresh()

#Acquire the graphics interface.
[System.Drawing.Graphics]$g = $f.CreateGraphics()

#Draw anything you like here using GDI+.
$g.DrawLine([System.Drawing.Pens]::Black, 50, 20, 450, 250)
$g.DrawLine([System.Drawing.Pens]::Black, 450, 20, 50, 250)

#Dispose the graphics interface.
$g.Dispose()

#Wait for 5 seconds before closing it all down.
Start-Sleep -s 5
$f.Close()
$f.Dispose()

To be continued.

When you type DIR, a list of DirectoryInfo and/or FileInfo objects are created and sent to the script host. Each object, no matter type, are displayed as strings, meaning that the directory name or file name is displayed. How ever, you can use the pipeline to access actual objects. I have some directories and a few files in my C root, so if I pipe the output from the DIR command to an iteration that displays the object’s type name, like so:

DIR C:\ | ForEach-Object { Write-Host $_.GetType().Name }

From that I will get the word DirectoryInfo for each directory and the word FileInfo for each file in my C root. These are the .NET classes that represent directories and files. Since the PowerShell pipeline actually is handling objects, you can use these objects by accessing the properties or calling the functions of each object. A simple task such as displaying the number of files in each directory, is a walk in the park, when the actual object you need to do this, already is in the pipeline.

DIR C:\ | ForEach-Object {
If ($_.GetType().Name -like "DirectoryInfo")
   {
      Write-Host $_.Name "(" $_.GetDirectories().Length
         " dirs and " $_.GetFiles().Length " files.)"
   }
}

The output for this, is the name of the directory and the number of child directories and files that it holds. I can see that my Windows folder holds 66 directories and 45 files.

Visual Basic doesn’t have any linguistic support for extension methods, but it can be done thanks to a method attribute. There are some rules for doing this. You must declare your sub or function in a standard module, not a class. You must have at least one parameter, and that parameter is the type you are extending. Any other parameters will be parameters in your function. Finally, your sub or function must have the System.Runtime.CompilerServices.Extension attribute.

So if you want to add a function that takes no parameters to the Integer type, you will have to define a function that takes one parameter, an Integer. If you want to add a function that takes one parameter, you will have to define a function that takes two parameter, the first must be an Integer and the second (who will serve as the first parameter in your function) can be of any type you like.

Public Function DoubleValue(ByVal I As Integer) As Integer
   Return I * 2
End Function

Remember, the code must be written in a standard module.

The last thing that you have to do, is to add the attribute.

<System.Runtime.CompilerServices.Extension()>
Public Function DoubleValue(ByVal I As Integer) As Integer
   Return I * 2
End Function

(The above code is VBx syntax. For older Visual Basic versions, add a blank followed by an underscore to the attribute line.)

Now you can call the DoubleValue function from any Integer, in this case 5:

Console.WriteLine(5.DoubleValue())

The output will of course be 10.