Thanks for your support over the years, and I wish you all happy coding!

--Paul

Here's my list of how to create and access things in Small Basic. I use this when I need to jog my memory but don't want to search through the Introducing Small Basic guide.

Create

Array:

myArray[1] = "myString"
TextWindow.WriteLine(Array.GetItemCount(myArray))

Directory:

File.CreateDirectory("C:\temp\myTempDir")

Ellipse:

GraphicsWindow.DrawEllipse(10, 15, 75, 25)

' Or...

myEllipse = Shapes.AddEllipse(100, 50)

Flickr image:

GraphicsWindow.DrawImage(Flickr.GetPictureOfMoment(), 0, 0)

For statement:

For i = 1 To 10
    TextWindow.WriteLine(i)
EndFor

If/Then statement:

If Clock.Year = 2010 Then
    TextWindow.WriteLine("2010")
Else
    TextWindow.WriteLine("Not 2010")  
EndIf 

Image:

myImage = Shapes.AddImage(ImageList.LoadImage("https://www.microsoft.com/about/images/home_blue.jpg"))

Label:

Goto myLabel

myLabel:
    TextWindow.WriteLine("Hello, World!")

Line:

GraphicsWindow.DrawLine(10, 20, 100, 50)

' Or...

myLine = Shapes.AddLine(15, 20, 40, 65) 

Rectangle:

GraphicsWindow.DrawRectangle(5, 15, 80, 35)

' Or...
 
myRectangle = Shapes.AddRectangle(50, 35)

Shape:

myEllipse = Shapes.AddEllipse(100, 50)

Stack:

Stack.PushValue("myStack", "myValue")
TextWindow.WriteLine(Stack.PopValue("myStack"))

Subroutine:

mySub()

Sub mySub
    TextWindow.WriteLine("Hello, World!")
EndSub

Triangle:

GraphicsWindow.DrawTriangle(10, 15, 50, 100, 75, 25)

' Or...
 
myTriangle = Shapes.AddTriangle(30, 10, 100, 75, 145, 35)

Access

Clock functions:

TextWindow.WriteLine(Clock.Date)

Desktop:

TextWindow.WriteLine(Desktop.Height)

Dictionary:

TextWindow.WriteLine(Dictionary.GetDefinition("banana"))

File functions:

TextWindow.WriteLine(File.GetTemporaryFilePath())

Graphics window:

GraphicsWindow.DrawBoundText(20, 10, 80, "Hello, World!")

Image:

GraphicsWindow.DrawImage(ImageList.LoadImage("https://www.microsoft.com/about/images/home_blue.jpg"), 0, 0)

Image list:

TextWindow.WriteLine(ImageList.GetHeightOfImage(ImageList.LoadImage("https://www.microsoft.com/about/images/home_blue.jpg")))

Math functions:

TextWindow.WriteLine(Math.SquareRoot(25))

Mouse:

GraphicsWindow.MouseDown = OnMouseDown

Sub OnMouseDown
    If Mouse.IsLeftButtonDown Then
        GraphicsWindow.Title = "Left button pressed"
    Else  
        GraphicsWindow.Title = "Left button not pressed"
    EndIf 
EndSub

Network functions:

TextWindow.WriteLine(Network.GetWebPageContents("https://www.microsoft.com/"))

Program functions:

TextWindow.WriteLine(Program.Directory)

Sound functions:

Sound.PlayBellRingAndWait()

Stack:

Stack.PushValue("myStack", "myValue")
TextWindow.WriteLine(Stack.PopValue("myStack"))

Text functions:

TextWindow.WriteLine(Text.GetLength("myText"))

Text window:

TextWindow.WriteLine("Hello, World!")

Timer:

Timer.Tick = OnTick
Timer.Interval = 5000

Sub OnTick
    TextWindow.WriteLine(Clock.Time)  
EndSub

Turtle:

Turtle.Move(100) 

Mark Forster, creator of the popular AutoFocus time management system, has come up with a new version which he is currently calling the "Day/Week/Month" (or "DWM") time management system. (Until now, he had been calling it "DIT2/AF5," which stood for "Do It Tomorrow 2/AutoFocus 5.")

DWM is a deceptively simple yet extremely powerful method for managing your time. To get started, if you prefer a paper-based implementation, a one-page-per-day diary format seems to work best. If however you prefer an electronic implementation, at minimum a way to sort list items works best (for example, Microsoft Office Excel or Microsoft Office Outlook Tasks).

Here's how it works:

1. For each new incoming task, set the task's due date to be one calendar month from today's date. For example, if today is February 11th, make the task due on March 11th.
2. Work on undone tasks, in any order you wish. When you finish working on a task, draw a line through it. 
3. If you start working on a task and don't finish it, change the task's due date to one calendar week from today. For example, if today is February 11th, make the task due on February 18th.
4. All tasks which are due earlier than today's date are expired. Draw a line through these tasks. They are dead and gone.
5. For a task with a firm due date, set the task's due date to that date.
6. If you're on vacation or otherwise unable to work on tasks, when you return, push out the tasks' due dates the number of days that you were gone. For example, if you are unable to work on tasks during February 13th - 14th, push out all of your tasks' due dates by two days. 
7. For paper-based implementations, write in the date at the top of each page. To move a task, just re-write it on the new page and cross off the old task. If you have to push out some tasks' due dates due to absences, just cross off the old due dates and write in the new due dates at the tops of the affected pages. 
8. For electronic implementations, in Excel you could use a column for due dates and sort them that way, or for Outlook you could use the Due Date field and sort them that way.

From the Microsoft Small Basic blog:

The Small Basic v0.8 release features:

• Addition of details about your published programs.
• Rating system for programs published online.
• Rich formatting based copy (useful for printing Small Basic programs).
• Keyword help in Intellisense plus code samples.
• Performance improvements in the Library APIs.
• In addition, we have localized Small Basic in three new languages, Chinese Traditional, Japanese and Portuguese.

The coolest feature in this release is the Silverlight player for Small Basic programs. Now you can run Small Basic programs on your browser without having to install the IDE.

For more information, go here.

I created a digital clock to demonstrate the Microsoft Small Basic Clock object. 

You can do any of the following to experiment with the clock and its underlying code:

• If you want to see the clock on your computer and you have Small Basic, click Import, type DHC348, click OK, and click Run.
• If you don't have Small Basic but you want see the clock, go to https://smallbasic.com/run/?programID=DHC348.  
• If you don't have Small Basic but you want to look at the code, go to https://smallbasic.com/program/?DHC348. 

You can now run Microsoft Small Basic programs in a Microsoft Silverlight-based viewer from a supported web browser. Here's how to do it:

1. If you want to run your own Small Basic program and you have not yet published it, from the Small Basic user interface, open the code that you want to publish, and then click Publish. Then write down the program ID that appears.
2. If you want to run a Small Basic program published by someone else, you must already know that program's ID.
3. Open your web browser and browse to the following URL: https://smallbasic.com/run/?programID= followed by the program ID; for example https://smallbasic.com/run/?programID=TPK457, https://smallbasic.com/run/?programID=TETRIS, or https://smallbasic.com/run/?programID=STARGATES.

Note that to interact with a running program, you must click inside of the viewer window, and then the program will recognize your key presses, mouse clicks, and so on.

Note that right now the viewer only appears to support programs that use the GraphicsWindow object. Programs that use other user interface constructs, such as the TextWindow object, don't appear to be supported as they currently display errors for me.

Here are the Microsoft Small Basic code examples that I've created so far. If you have Small Basic, you can import them by using the ID numbers below, or you simply click the hyperlinks to display the code in your web browser: 

• Arrays: BTD771, https://smallbasic.com/program/?BTD771
• Basic Shape Movement with Mouse: VDJ792, https://smallbasic.com/program/?VDJ792
• Clock: BJF410, https://smallbasic.com/program/?BJF410
• Desktop: CQK329, https://smallbasic.com/program/?CQK329
• Dictionary: FMG125, https://smallbasic.com/program/?FMG125
• Draw "Hi!": KXL619, https://smallbasic.com/program/?KXL619
• File Input and Output: HDF235, https://smallbasic.com/program/?HDF235
• Flickr: CDK203, https://smallbasic.com/program/?CDK203
• Graphics Window: GLT000, https://smallbasic.com/program/?GLT000
• Image List: HVK076, https://smallbasic.com/program/?HVK076
• Keywords: XNL147, https://smallbasic.com/program/?XNL147
• Math Functions: BQG495, https://smallbasic.com/program/?BQG495 
• Math Guessing Game: XLD240, https://smallbasic.com/program/?XLD240
• Mouse and Keyboard Input: QXJ907, https://smallbasic.com/program/?QXJ907
• Mouse Events: DJD823, https://smallbasic.com/program/?DJD823
• Network Operations: CTR549, https://smallbasic.com/program/?CTR549
• Program Operations: MBD550, https://smallbasic.com/program/?MBD550
• Shapes: MTF058, https://smallbasic.com/program/?MTF058
• Sounds: MXG933, https://smallbasic.com/program/?MXG933
• Stack Operations: LXW659, https://smallbasic.com/program/?LXW659
• Subroutines: DDL952, https://smallbasic.com/program/?DDL952
• Text Operations: VVW227, https://smallbasic.com/program/?VVW227
• Text Window Operations: QQV366, https://smallbasic.com/program/?QQV366
• Trigonometric Functions: CLN862, https://smallbasic.com/program/?CLN862
• Turtle Says "Hi!": TPK457, https://smallbasic.com/program/?TPK457

Microsoft Small Basic provides a Turtle object that lets you draw on the graphics window with a little turtle. You can make the turtle crawl around, drawing wherever you lead it, as demonstrated in the following code that draws the word "Hi!" near the middle of the graphics window:

' Center of the graphics window.
w = GraphicsWindow.Width / 2
h = GraphicsWindow.Height / 2

' Move the turtle to the center of the graphics window.
Turtle.Show()
Turtle.X = w
Turtle.Y = h

' Make the turtle draw fast (but not too fast!).
Turtle.Speed = 7

' Draw the "H" in "Hi!"
Turtle.Turn(180) ' Turns the turtle at the specified speed.
Turtle.Move(40)
Turtle.MoveTo(w, h + 20) ' Same as Turtle.X with Turtle.Y, but moves at specified speed instead of instantly.
Turtle.TurnRight()
Turtle.Move(20)
Turtle.MoveTo(w + 20, h) 
Turtle.Angle = 180 ' Same as Turtle.Turn(180), but Turtle.Angle turns instantly.
Turtle.Move(40)

' Draw the "i" in "Hi!"
Turtle.X = w + 30 ' Same as first part of Turtle.MoveTo, but moves instantly and doesn't draw while moving.
Turtle.Y = h ' Same as second part of Turtle.MoveTo, but moves instantly and doesn't draw while moving.
Turtle.PenUp() ' Now, when the turtle moves, it won't also draw.
Turtle.Move(10)
Turtle.PenDown() ' Now the turtle draws as it moves.
Turtle.Move(5)
Turtle.PenUp() ' Stop drawing.
Turtle.Move(5)
Turtle.PenDown() ' Start drawing again.
Turtle.Move(20)

' Draw the "!" in "Hi!"
Turtle.X = w + 40
Turtle.Y = h
Turtle.Move(30)
Turtle.PenUp()
Turtle.Move(5)
Turtle.PenDown()
Turtle.Move(5)

Turtle.Hide()

Although not quite as fun, you can accomplish the same thing with the graphics window's DrawLine operation, as demonstrated in the following code:

' Center of the graphics window.
w = GraphicsWindow.Width / 2
h = GraphicsWindow.Height / 2

' Draw the "H" in "Hi!"
GraphicsWindow.DrawLine(w, h, w, h + 40)
GraphicsWindow.DrawLine(w, h + 20, w + 20, h + 20)
GraphicsWindow.DrawLine(w + 20, h, w + 20, h + 40)

' Draw the "i" in "Hi!"
GraphicsWindow.DrawLine(w + 30, h + 10, w + 30, h + 15)
GraphicsWindow.DrawLine(w + 30, h + 20, w + 30, h + 40)

' Draw the "!" in "Hi!"
GraphicsWindow.DrawLine(w + 40, h, w + 40, h + 30)
GraphicsWindow.DrawLine(w + 40, h + 35, w + 40, h + 40)

If you're interested in creating basic text-based programs, Microsoft Small Basic has TextWindow and Text objects are probably enough for your needs. However, if you're interested in interactive graphical programs (such as games or rich personal productivity applications), Microsoft Small Basic has a GraphicsWindow object that supports mouse and keyboard events. To learn about how it works, you can try importing the following code into Small Basic using ID KKG377 and then running it:

' Standard code for hooking up key, mouse, and text input actions to the graphics window.
GraphicsWindow.KeyDown = OnKeyDown
GraphicsWindow.KeyUp = OnKeyUp
GraphicsWindow.MouseDown = OnMouseDown
GraphicsWindow.MouseMove = OnMouseMove
GraphicsWindow.MouseUp = OnMouseUp
GraphicsWindow.TextInput = OnTextInput

Sub OnKeyDown
  ' Code for key presses goes here. 
  GraphicsWindow.Title = "'" + GraphicsWindow.LastKey + "' pressed" 
EndSub

Sub OnKeyUp
  ' Code for key releases goes here.
  GraphicsWindow.Title = "'" + GraphicsWindow.LastKey + "' released"
EndSub

Sub OnMouseDown
  ' Code for mouse button presses goes here.
  If Mouse.IsLeftButtonDown Then
    GraphicsWindow.Title = "Left button pressed"
  ElseIf Mouse.IsRightButtonDown Then
    GraphicsWindow.Title = "Right button pressed"
  Else
    GraphicsWindow.Title = "Some mouse button pressed (other than left and right)"
  EndIf
EndSub

Sub OnMouseMove
  ' Code for mouse moves goes here.
  ' GraphicsWindow.MouseX and GraphicsWindow.MouseY are relative to the graphics window.
  ' Mouse.MouseX and Mouse.MouseY are relative to the entire screen, which is typically bigger than the graphics window.
  GraphicsWindow.Title = "GWX = " + GraphicsWindow.MouseX + ", GWY = " + GraphicsWindow.MouseY + ", ScreenX = " + Mouse.MouseX + ", ScreenY = " + Mouse.MouseY
EndSub

Sub OnMouseUp
  ' Code for mouse button releases goes here.
  GraphicsWindow.Title = "Some mouse button released"
EndSub

Sub OnTextInput
  ' Code for text inputs goes here.  
EndSub

Notice that as you move the mouse, click and release mouse buttons, and press and release keys on the keyboard, the graphics window displays information about the mouse and key events. You can use this information to make your program take action in response to these events.