New to Programming?

If you're new to programming in general, you should probably learn what 
some basic concepts are:

How Your Program Is Run
   *What a Compiler Is
   *Syntax
   *Program Flow
Variables
-Basic DataTypes
Input/Output (IO)

The above being the most important programming concepts for an absolute 
beginner to programming to learn.  I will go over how these concepts work 
in FreeBASIC.  It is also important to learn how to use the manual, located 
at www.freebasic.net/wiki  Most programming communities and language will 
have manuals with both descriptions and demonstrations.  ALWAYS refer to 
the manual before looking elsewhere.  Chances are the information you want 
is in the manual, and if it's not, it can be added.

This tutorial's on Version 1.0.  Don't care for the revision number ^^;;

How Your Program is Run

What a Compiler Is

FreeBASIC is a compiled programming language, rather than interpreted.  
What this means, is that FreeBASIC takes the code that you type in, such as 
"PRINT" or "SLEEP" and translates that directly into Assembly or Machine 
Code.  Assembler and Machine Code are what the computer understands.  In 
general, you will never code in Machine Code, no matter how "low level" 
(how close you are to programming machine code) you go.

FreeBASIC is a High Level programming language.  FreeBASIC makes it so the 
programmer has to do less work to get more done.  With higher level 
programming, you don't have to worry about the more complex areas of 
programming.  In programming languages such as C and ASM, which are lower 
level, the programmer has the advantage of manipulating the computer on a 
more precise and less human level, with the disadvantage of having to know 
more about internals.

Your compiler of choice will depend on your situation.  If you want 
complete control over every action being taken by your computer, you may 
wish to code in ASM or C.  However, as computers and compilers have 
progressed, you no longer have to worry as much about the speed and lower 
level details of your code.  In many ways, the entire purpose of higher 
level programming is to make sure you don't have to worry about those 
things.  FreeBASIC handles many optimizations and improvements that you 
would normally have to do by hand for you, while still allowing you to 
access lower level areas of control if you wish.  One problem with this, 
however, which is a common problem in most higher level forms of 
programming, is the high levels of implicit actions being taken by the 
compiler.  If you want to work with lower level code in a higher level 
language, you need to know how to explicitly control certain aspects of 
your code.

Syntax

Syntax is how words and commands are grouped together in programming.  The 
order that they are in, what commands are allowed where, and if consistent, 
will lay down rules as to how you will structure your program.

For example, in programming, you will come across the task of calling 
commands, and giving those commands something to do.  Your syntax rules 
will tell you how you can call this command, and what is or isn't allowed.  
They will help you call the command intelligently, and help prevent 
possible errors that could occur in a more "syntax free" (what is 
essentially impossible in most forms of programming) environment.

The syntax for FreeBASIC generally goes as follows:  CommandName [Argument,
] [Another Argument]

While the above may look confusing at first, it's actually very simple.  
All that says is that you give the compiler a command, and then give your 
arguments after the command.  The comma is what separates the arguments 
from one another.  An example command could be:  Draw Circle, 10.  We can 
assume that Draw will draw something, Circle will be the shape that it 
draws, and 10 will be the radius of the circle being drawn.  In that case, 
the syntax rules for that command may look something like this:  Draw [
Shape,] [Size]

FreeBASIC is *not* case sensitive.  Calling a command 'DRaW' is the same as 
calling the command 'draw'.

Program Flow

FreeBASIC's code is read from the TOP of the code, to the BOTTOM, one line 
at a time.  When the line of code is read by the compiler, or the compiled 
code for that line is read by the computer, the command that's on the line 
will be executed (it will be ran, it will happen, your computer will do 
what the code tells it to).  Example code can be:

   Print "HI"
   Sleep

Since the code PRINT is on the line above SLEEP, PRINT will be run first.  
SLEEP is the next line and will be executed after PRINT is finished 
executing.

Comments can be made in FreeBASIC, which are ignored, and will not become a 
part of your program.  Comments can take up a full line if you begin them 
with ', or can be multiple line comments if you begin them with /' and end 
them with '/.  Here's an example of using comments.  Notice how none of the 
code or characters within the comments are even noticed by the compiler.

   '  ABLASHD
   ' PRINT "HI!" ' This line of code will never even be printed, because it's commented.
   Print "This is not a comment.  This event will occur."  ' Print that it's not a comment onto the screen.
   Sleep ' pause the program until the user hits a key.

Variables

What are variables?  They're the most important part of programming, that's 
what.  Any time you do anything useful in programming, you're going to 
store information in variables.

Do you recall doing algebra or using letters in math, in school?  An 
example might be something like:  x = 4, 1 + x = 5.  When programming, 
variables are exactly that.  They are words or letters that hold values in 
programming.  These values may store important data such as a name, how 
much health your main character in your video game has, or even something 
as simple as the color of one pixel.  When you make a variable, you 
actually are storing the data it holds small piece of the computer's 
memory.  In FreeBASIC, and most programming languages, you will work with 
variables a lot.

To create variables in FreeBASIC, we use the DIM command.  What does DIM 
stand for?  I'm not sure, but it could stand for DIMENSION, where 
programmers would define the "size" of their variable.  DIM is used to tell 
FreeBASIC that we're creating a new variable in our program.  The command 
is described in high detail on This Page, but we're going to explain it in 
less detail here.

The most simple syntax for DIM is:  DIM [VariableName] AS [DataType] [="[
Value] ]

What this does, is it tells FreeBASIC:
- We're making a variable, because we typed in the command DIM
- We're naming the variable [VariableName] (Where VariableName is the name 
of the variable you want to make.  A variable can be named X, Y, 
AlexPritchard, BLahblh, Foo, etc.)
- We're specifying the type of variable, because we typed in AS after 
VariableName
- We're making the variable of the type [DataType] (Datatype can be 
something that holds numbers, letters, or a whole bunch of stuff!)
- We can also assign the value of the variable by putting EQUALS (=) after 
our variable creation.

Example:
   Dim foo As Integer = 5
   Print foo
   Sleep

In our program, we created foo. FOO was created as an INTEGER (A datatype 
which holds numbers) We gave foo the value of 5.  We then call the command 
PRINT, which PRINTS information on our screen.  We PRINT foo, so the number 
5 should be PRINTed on the screen.  We then SLEEP, which pauses our program 
until we hit a key.

Basic DataTypes

Variables are a tough subject, I think, to begin with in programming.  
There's a lot of different types of variables!  The type of variable is the 
data type.  'The kind of data that's held in this type of variable', and 
you wondered why they shortened it to datatype?  ^^;;  For starters, we'll 
get you familiar with these types of variables:

Integer - Hold numbers WITHOUT DECIMAL PLACES.  Will generally be the size 
of your computer's registry, which is not a topic I will be going over.
Double - Holds numbers WITH DECIMAL PLACES.  Holds very large and small 
numbers, with high levels of precision (how close to any value you give the 
variable it's actual value will be)
String - A nice feature in FreeBASIC.  STRING is a datatype which holds 
letters and numbers for you.  Built for storing information such as your 
name, and cool information to put on the screen, such as cooking 
directions.

Remember, follow the proper DIM syntax.  DIM variablename as INTEGER will 
make an INTEGER called variablename, which you can use in your program.  
You can replace INTEGER with DOUBLE, or STRING.  BE CAREFUL!  Data Types 
are *NOT* always compatible with each other!  You can not give a STRING the 
value of 5!  You can however, give it the value of "5" (quotes specify 
string characters in FB).  You can not have an integer or double equal "5", 
as "5" is a string, and not a number.

Here is a really cool example, which demonstrates how you can use variables 
to store your name.

   '' Create the variable MyName.  Assign it's value to be 'Alex'
   Dim As String MyName = "Alex"

   '' Print The MyName variable
   Print MyName

   '' pause the program until the user hits a key.
   Sleep

Input/Output

Input is the receiving of information.  When your get input on something, 
someone or something else is giving it to you.  You are getting their 
ouput.  (GETTING SOMETHING, Retrieving Something)

Output is the sending of information.  When you ouput to something, you're 
the one giving input to them.  (GIVING SOMETHING, Sending Something)

Input and Output are often put together, and are shortened as I/O, or IO.

FreeBASIC has MANY methods of input and output.  For a beginner, most of 
these could end up confusing you, because they generally require better 
knowledge of variables and more complex forms of programming.  We're going 
to study the very basics of I/O.

You remember the command PRINT in the above examples?  That's OUTPUT.  
PRINT OUTPUTS to the computer screen.  PRINT is a very basic form of 
output, and it's easy to learn, too!  You just call the command PRINT, then 
tell it what you want it to print.  If you want to Print words, you put 
those enclosed in Double-Quotes.  If you want to print variables, you just 
give PRINT the name of the variable you want to print.

Print [WhatToPrint]
Example:

   '' Print the words, HI! to the screen
   Print "HI!"

   '' create a new integer and name it foo.  Give it the value of 10.
   Dim As Integer foo = 10

   '' Print the value of foo.
   Print foo
   Sleep

INPUT isn't much harder, either.  However, whenever you input, you have to 
get that input and put it into something.  Just how like in order to give 
output, we have to give the PRINT command something to output.  We already 
know variables, right?  We will use our variables to store information that 
the user inputs.

1) We need a variable to store that information in.
2) We need to call a command to get input.
3) We need to print the input to make sure we stored the information 
correctly.

I know how to do 1 and 3, but what about 2?  We're going to learn a new 
command for this.  Can you guess it's name?  INPUT!  Yup ^^;; To get INPUT, 
we will use the command, INPUT.

Input's syntax is as follows:  INPUT [VariableToInputTo]

You can also use input like so:  INPUT [Output String To Tell User What to 
Input,] [VariableToInputTo]

The first version of INPUT will let you get input, and put it right into 
the variable.  The second version OUTPUTS your message to the screen before 
asking for input.  This way, the user will know what to input!  
Alternatively, you can just use the PRINT command before INPUT to send the 
user a message, but sometimes being able to put related code on one line is 
a convenience.

Example:

   '' Create a string.  We will hold the user's name in the string!
   Dim As String MyName

   '' Get the user's name!
   '' The message Please Enter Your Name is posted on the screen,
   '' and then the user has a chance to enter in their name!
   Input "Please enter your name!", MyName

   '' Print the user's name that we just got.
   '' Just like input, we can print several messages or
   '' execute different types of commands by separating them by commas.
   Print "Your Name Is: ", MyName

   '' pause the program until the user hits a key
   Sleep

That demonstrates both INPUT and OUTPUT!  Both are essential in 
programming, or at least graphical programming.  OUTPUT can be many 
different things, as well as INPUT.  You might be getting input from a 
robotic arm's sensors rather than from the user's keyboard.  You might be 
outputting to a power drill rather than a monitor.  It really depends on 
the hardware and the purpose of your program.

At the time, and in most cases, you don't have to worry so much about where 
the input comes from, or where it's going to when dealing with your 
standard I/O functions.  More advanced methods of I/O let you decide where 
it's coming from (which input to get) and where it's going to (where to 
send output to).

Programming Definitions

Argument:  See Parameter

ASM:  The lowest level code that a human will want to read.  This can be 
compiled directly into machine code.

Compiling:  The process of turning text in one language to another.  Ex:  
BASIC in FreeBASIC compiles into ASM.  That ASM compiles into machine code.

Machine Code:  0's and 1's.  This is *the* code that your computer will 
understand.

Parameter:  Data that you pass to a command you call in programming.  
Parameters being passed allow commands to be directed as to HOW they will 
do something, or what they will do.  Passing a parameter 'Rectangle' to a 
command 'Draw', it would make sense if that drew a rectangle onto your 
screen.

Pixel:  One 'dot' on your monitor.  Monitors are made up of thousands of 
tiny dots which are lit up of different colors.  The color depends on the 
value of the pixel variable that the monitor receives.  Believe it or not, 
even your hardware will use variables, in many ways.

Syntax:  How words are grouped together.  Your syntax in programming are 
sets of rules that tell you what code can be placed where.  It makes sure 
that only logical code is allowed.  Ex:  Print "Hi".  PRINT is the COMMAND, 
"Hi" is what the command will PRINT.  Make sense?

Variable:  A word that holds data in programming.  You assign these words 
values, and with those values, you can save information on your program.

Last Reviewed by Sancho3 on February 06, 2018